from time import *
import sys
from random import*
import turtle
import time
import random
import json
战斗是 = 'NO'
# 需完成:队友模式 削弱技能 背包队友模式 更多敌人数据
def 写信息():
    with open("#",'a') as f:
        f.write(写入的信息)

def 保存():
    玩家 = [章节, 游戏进程, 血量, 经验, 武器, 防具, 护符, 金币, 杀死敌人数量]
    世界 = [0]
    技能 = 玩家的技能信息储存
    背包的物品 = [背包物品[0],背包物品[1],背包物品[2],背包物品[3],背包物品[4],背包物品[5],背包物品[6]]
    队友信息 = [队友B血量,队友B经验,队友B武器,队友B防具,队友B护符,队友C血量,队友C经验,队友C武器,队友C防具,队友C护符,队友数量]
    设置选项 = [是否快进]
    data = {
        "player": 玩家,
        "world": 世界,
        "skill":技能,
        "knapsack":背包的物品,
        "team":队友信息,
        "die people":人物死亡名称列表,
        "set up": 设置选项
    }

    with open('数据储存/存档/data.json', 'w') as f:
        json.dump(data, f)

    with open('数据储存/存档/名字', 'w') as f:
        f.write(名字)

def 读档():
    global 名字
    global 游戏进程
    global 章节
    global 血量
    global 经验
    global 武器
    global 防具
    global 护符
    global 玩家的技能信息储存
    global 背包物品
    global 队友B血量
    global 队友B经验
    global 队友B武器
    global 队友B防具
    global 队友B护符
    global 队友C血量
    global 队友C经验
    global 队友C武器
    global 队友C防具
    global 队友C护符
    global 队友数量
    global 队友B名字
    global 队友C名字
    global 金币
    global 杀死敌人数量
    global 人物死亡名称列表
    global 是否快进
    # 读取保存信息
    with open("数据储存/存档/data.json", 'r') as f:
        data = json.load(f)
    玩家 = data["player"]
    章节 = 玩家[0]
    游戏进程 = 玩家[1]
    血量 = 玩家[2]
    经验 = 玩家[3]
    武器 = 玩家[4]
    防具 = 玩家[5]
    护符 = 玩家[6]
    金币 = 玩家[7]
    杀死敌人数量 = 玩家[8]
    队友信息 = data["team"]
    队友B血量 = 队友信息[0]
    队友B经验 = 队友信息[1]
    队友B武器 = 队友信息[2]
    队友B防具 = 队友信息[3]
    队友B护符 = 队友信息[4]
    队友C血量 = 队友信息[5]
    队友C经验 = 队友信息[6]
    队友C武器 = 队友信息[7]
    队友C防具 = 队友信息[8]
    队友C护符 = 队友信息[9]
    队友数量 = 队友信息[10]
    世界 = data["world"]
    玩家的技能信息储存 = data["skill"]
    背包物品 = data["knapsack"]
    人物死亡名称列表 = data["die people"]
    设置选项 = data["set up"]
    是否快进 = 设置选项[0]
    
    with open("数据储存/存档/名字") as f:
        名字 = f.read()

with open("数据储存/剧情编辑器") as T:
    语言列表 = T.read()
    语言列表 = 语言列表.split('/')

with open("数据储存/敌人信息编辑器", 'r') as T:
    敌人信息列表 = T.read()
    敌人信息列表 = 敌人信息列表.split('/')

with open("数据储存/技能信息储存", 'r') as T:
    技能信息列表 = T.read()
    技能信息列表 = 技能信息列表.split('/')

with open("数据储存/章节顺序编辑器", 'r') as f:
    章节列表 = f.read()
    章节列表 = 章节列表.split('/')

with open("数据储存/物品信息储存", 'r') as f:
    物品信息列表 = f.read()
    物品信息列表 = 物品信息列表.split('/')

with open("数据储存/敌人AI信息储存", 'r') as T:
    敌人AI信息列表 = T.read()
    敌人AI信息列表 = 敌人AI信息列表.split('/')

def printx(text, timee):
    if (是否快进 == 0):
        for i in text:
            sleep(timee)
            print(i, end='', flush=True)
            sys.stdout.flush()
        input("")
    else:
        input(text)

def 获得物品(物品名称):
    global 物品信息列表
    if (int(背包物品[0]) == 0):
        背包物品[0] = 物品名称
    else:
        if (int(背包物品[1]) == 0):
            背包物品[1] = 物品名称
        else:
            if (int(背包物品[2]) == 0):
                背包物品[2] = 物品名称
            else:
                if (int(背包物品[3]) == 0):
                    背包物品[3] = 物品名称
                else:
                    if (int(背包物品[4]) == 0):
                        背包物品[4] = 物品名称
                    else:
                        if (int(背包物品[5]) == 0):
                            背包物品[5] = 物品名称
                        else:
                            if (int(背包物品[6]) == 0):
                                背包物品[6] = 物品名称
                            else:
                                printx('然而你的背包装满了 物品看见你不收留它消失啦!',0.1)

def 显示背包():
    global 回答
    物品A = 物品信息列表[int(背包物品[0])]
    物品A = 物品A.split(',')
    物品B = 物品信息列表[int(背包物品[1])]
    物品B = 物品B.split(',')
    物品C = 物品信息列表[int(背包物品[2])]
    物品C = 物品C.split(',')
    物品D = 物品信息列表[int(背包物品[3])]
    物品D = 物品D.split(',')
    物品E = 物品信息列表[int(背包物品[4])]
    物品E = 物品E.split(',')
    物品F = 物品信息列表[int(背包物品[5])]
    物品F = 物品F.split(',')
    物品G = 物品信息列表[int(背包物品[6])]
    物品G = 物品G.split(',')
    print('@-------------背包------------@')
    sleep(0.05)
    print(f'1.{物品A[0]} [可售{物品A[4]}元]')
    sleep(0.05)
    print(f'2.{物品B[0]} [可售{物品B[4]}元]')
    sleep(0.05)
    print(f'3.{物品C[0]} [可售{物品C[4]}元]')
    sleep(0.05)
    print(f'4.{物品D[0]} [可售{物品D[4]}元]')
    sleep(0.05)
    print(f'5.{物品E[0]} [可售{物品E[4]}元]')
    sleep(0.05)
    print(f'6.{物品F[0]} [可售{物品F[4]}元]')
    sleep(0.05)
    print(f'7.{物品G[0]} [可售{物品G[4]}元]')
    sleep(0.05)
    print('@-----------输入选项----------@')
    sleep(0.05)
    回答 = ''
    while True:
        if (回答 == '1' or 回答 == '2' or 回答 == '3' or 回答 == '4'):
            break
        else:
            回答 = input('1.使用 2.查看 3.丢弃 4.退出 > ')

def 背包系统整理():
    global 回答
    global 血量
    global 攻击
    global 内力值
    global 防御
    global 武器
    global 防具
    global 护符
    global 免疫状态
    global 状态
    global 战斗是
    while True:
        显示背包()
        物品A = 物品信息列表[int(背包物品[0])]
        物品A = 物品A.split(',')
        物品B = 物品信息列表[int(背包物品[1])]
        物品B = 物品B.split(',')
        物品C = 物品信息列表[int(背包物品[2])]
        物品C = 物品C.split(',')
        物品D = 物品信息列表[int(背包物品[3])]
        物品D = 物品D.split(',')
        物品E = 物品信息列表[int(背包物品[4])]
        物品E = 物品E.split(',')
        物品F = 物品信息列表[int(背包物品[5])]
        物品F = 物品F.split(',')
        物品G = 物品信息列表[int(背包物品[6])]
        物品G = 物品G.split(',')
        查看的选项 = ''
        if(回答 == '1'):
            while True:
                if (查看的选项 == '1' or 查看的选项 == '2' or 查看的选项 == '3' or 查看的选项 == '4' or 查看的选项 == '5' or 查看的选项 == '6' or 查看的选项 == '7'):
                    break
                else:
                    查看的选项 = input('输入使用的选项 > ')
            查看的选项 = int(查看的选项)
            删除的选项 = 查看的选项
            查看的选项 = 物品信息列表[背包物品[查看的选项-1]]
            查看的选项 = 查看的选项.split(',')
            if (not 查看的选项[2] == '装饰'):
                if (查看的选项[2] == '药品'):
                    血量 += int(查看的选项[3])
                    if (血量 > 血量上限):
                        血量 = 血量上限
                    printx(f'[{名字}]使用了[{查看的选项[0]}] 回复了{int(查看的选项[3])}血量', 0.1)

                if (查看的选项[2] == '攻击增加'):
                    攻击 += int(查看的选项[3])
                    printx(f'[{名字}]使用了[{查看的选项[0]}] 攻击增加{int(查看的选项[3])}', 0.1)
                
                if (查看的选项[2] == '内力增加'):
                    内力值 += int(查看的选项[3])
                    printx(f'[{名字}]使用了[{查看的选项[0]}] 内力增加{int(查看的选项[3])}', 0.1)

                if (查看的选项[2] == '防御增加'):
                    防御 += int(查看的选项[3])
                    printx(f'[{名字}]使用了[{查看的选项[0]}] 防御增加{int(查看的选项[3])}', 0.1)
                
                if (查看的选项[2] == '武器'):
                    回答 = int(回答)
                    if (武器 == 0):
                        武器 = int(查看的选项[5])
                        printx(f'[{名字}]装备了[{查看的选项[0]}] 攻击增加{int(查看的选项[3])}', 0.1)
                        攻击 += int(查看的选项[3])
                    else:
                        printx(f'[{名字}]已经装备了其他武器 是否替换?', 0.1)
                        回答B = ''
                        while True:
                            if (回答B == '1' or 回答B == '2'):
                                break
                            else:
                                回答B = input('1.是 2.否 > ')

                        if (回答B == '1'):
                            查看的选项B = 物品信息列表[武器]
                            查看的选项B = 查看的选项B.split(',')
                            攻击 -= int(查看的选项B[3])
                            获得物品(武器)
                            武器 = int(背包物品[回答-1])
                            printx(f'[{名字}]装备了[{查看的选项[0]}] 攻击增加{int(查看的选项[3])}', 0.1)
                            攻击 += int(查看的选项[3])

                if (查看的选项[2] == '防具'):
                    回答 = int(回答)
                    if (防具 == 0):
                        防具 = int(查看的选项[5])
                        printx(f'[{名字}]装备了[{查看的选项[0]}] 防御增加{int(查看的选项[3])}', 0.1)
                        防御 += int(查看的选项[3])
                    else:
                        printx(f'[{名字}]已经装备了其他防具 是否替换?', 0.1)
                        回答B = ''
                        while True:
                            if (回答B == '1' or 回答B == '2'):
                                break
                            else:
                                回答B = input('1.是 2.否 > ')
                                
                        if (回答B == '1'):
                            查看的选项B = 物品信息列表[防具]
                            查看的选项B = 查看的选项B.split(',')
                            防御 -= int(查看的选项B[3])
                            获得物品(防具)
                            防具 = int(背包物品[回答-1])
                            printx(f'[{名字}]装备了[{查看的选项[0]}] 防御增加{int(查看的选项[3])}', 0.1)
                            防御 += int(查看的选项[3])
                
                if (查看的选项[2] == '护符'):
                    回答 = int(回答)
                    if (护符 == 0):
                        护符 = int(查看的选项[5])
                        printx(f'[{名字}]装备了[{查看的选项[0]}] 可以免疫{(查看的选项[3])}状态', 0.1)
                        免疫状态 = 查看的选项[3]
                    else:
                        printx(f'[{名字}]已经装备了其他防具 是否替换?', 0.1)
                        回答B = ''
                        while True:
                            if (回答B == '1' or 回答B == '2'):
                                break
                            else:
                                回答B = input('1.是 2.否 > ')
                                
                        if (回答B == '1'):
                            查看的选项B = 物品信息列表[护符]
                            查看的选项B = 查看的选项B.split(',')
                            免疫状态 = ''
                            获得物品(护符)
                            护符 = int(背包物品[回答-1])
                            printx(f'[{名字}]装备了[{查看的选项[0]}] 可以免疫{查看的选项[3]}状态', 0.1)
                            免疫状态 = 查看的选项[3]

                if (查看的选项[2] == '药草'):
                    消除状态 = 查看的选项[3]
                    寻找准确配对的状态编号 = 0
                    是否配对成功 = 0
                    for __count in range(len(状态)):
                        寻找准确配对的状态信息 = 状态[寻找准确配对的状态编号]
                        if (消除状态[0] == 寻找准确配对的状态信息[0]):
                            是否配对成功 = 1
                            break
                        寻找准确配对的状态编号 =+ 1

                    if (是否配对成功 == 1):
                        消除状态等级 = 查看的选项[3]
                        消除状态等级 = 消除状态等级[2]
                        if (消除状态等级 == '一'):
                            消除状态等级 = 1
                        if (消除状态等级 == '二'):
                            消除状态等级 = 2
                        if (消除状态等级 == '三'):
                            消除状态等级 = 3
                        寻找准确配对的状态信息 = 状态[寻找准确配对的状态编号]
                        寻找准确配对的状态等级 = 寻找准确配对的状态信息[2]
                        if (寻找准确配对的状态等级 == '一'):
                            寻找准确配对的状态等级 = 1
                        if (寻找准确配对的状态等级 == '二'):
                            寻找准确配对的状态等级 = 2
                        if (寻找准确配对的状态等级 == '三'):
                            寻找准确配对的状态等级 = 3
                        if (消除状态等级 >= 寻找准确配对的状态等级):
                            printx(f'[{名字}]使用了[{查看的选项[0]}] 消除状态[{查看的选项[3]}]', 0.1)
                            del 状态[状态.index(查看的选项[3])]
                    else:
                        printx(f'[{名字}]使用了[{查看的选项[0]}] 似乎啥效果都没有', 0.1)
                    
                del 背包物品[删除的选项-1]
                背包物品.append('0')
            else:
                printx('你在期待什么?', 0.1)

        if(回答 == '2'):
            while True:
                if (查看的选项 == '1' or 查看的选项 == '2' or 查看的选项 == '3' or 查看的选项 == '4' or 查看的选项 == '5' or 查看的选项 == '6' or 查看的选项 == '7'):
                    break
                else:
                    查看的选项 = input('输入查看的选项 > ')
            查看的选项 = int(查看的选项)
            查看的选项 = 物品信息列表[背包物品[查看的选项-1]]
            查看的选项 = 查看的选项.split(',')
            printx(查看的选项[1],0.1)

        if(回答 == '3'):
            while True:
                if (查看的选项 == '1' or 查看的选项 == '2' or 查看的选项 == '3' or 查看的选项 == '4' or 查看的选项 == '5' or 查看的选项 == '6' or 查看的选项 == '7'):
                    break
                else:
                    查看的选项 = input('输入删除的选项 > ')
            查看的选项 = int(查看的选项)
            # 储存名字
            删除名称储存 = 物品信息列表[背包物品[查看的选项-1]]
            删除名称储存 = 删除名称储存.split(',')
            if (not 删除名称储存[0] == '----'):
                printx(f'[{删除名称储存[0]}]被你狠狠的扔了出去!!', 0.1)
                del 背包物品[查看的选项-1]
                背包物品.append('0')
            else:
                printx('你个憨批想蛤呢??', 0.1)

        if(回答 == '4'):
            break

        if (战斗是 == 'YES'):
            break

def 说话系统():
    global 语言列表
    global 名字
    global 技能信息列表
    global 血量
    global 血量上限
    global 攻击
    global 防御
    global 内力值
    global 内力值上限
    global 金币
    global 经验
    global 防具
    global 武器
    global 胜利条件
    global 回答
    global 护符
    global 免疫状态
    global 杀死敌人数量
    global 状态
    global 战斗是
    说话内容 = 0
    # 储存说话编号内所指示的数据
    说话系统_语言列表 = 语言列表[说话文件编号]
    说话系统_语言列表 = 说话系统_语言列表.split(',')

    重复说话可执行数 = len(说话系统_语言列表)
    # 也等同于起始说话内容的开始话句
    for __count in range(重复说话可执行数):
        if (说话系统_语言列表[说话内容] == ">"):
            global 回答
            回答 = input("输入操作>>> ")

        elif (说话系统_语言列表[说话内容] == "[名字]"):
            printx(名字,0.1)

        elif (说话系统_语言列表[说话内容] == "[等待]"):
            global timee
            printx("....",0.5)

        elif (说话系统_语言列表[说话内容] == "###"):
            print("O-----------------------------O")

        elif (说话系统_语言列表[说话内容] == "[战斗]"):
            战斗是 = 'YES'
            print('O-----------------------------O')
            敌人编号 = [说话系统_语言列表[说话内容+1], 说话系统_语言列表[说话内容+2], 说话系统_语言列表[说话内容+3]]
            
            if (not 敌人编号[0] == 'Nome'):
                敌人信息A = 敌人信息列表[int(敌人编号[0])]
                敌人信息A = 敌人信息A.split(',')

            if (not 敌人编号[1] == 'Nome'):
                敌人信息B = 敌人信息列表[int(敌人编号[1])]
                敌人信息B = 敌人信息B.split(',')

            if (not 敌人编号[2] == 'Nome'):
                敌人信息C = 敌人信息列表[int(敌人编号[2])]
                敌人信息C = 敌人信息C.split(',')
            # 战斗开始
            if (敌人编号[1] == 'Nome'):
                if (敌人信息A[12] == '被攻击' or 敌人信息A[12] == '#'):
                    printx(f'[{名字}]向[{敌人信息A[0]}]发起了战斗', 0.1)
                if (敌人信息A[12] == '攻击'):
                    printx(f'[{名字}]遭遇[{敌人信息A[0]}]的战斗', 0.1)
                if (敌人信息A[12] == '路过'):
                    printx(f'[{敌人信息A[0]}]路过你身边...', 0.1)

                血量A = int(敌人信息A[5])
                血量A上限 = int(敌人信息A[5])
                攻击A = int(敌人信息A[6])
                防御A = int(敌人信息A[7])
                内力值A上限 = int(敌人信息A[8])
                内力值A = int(敌人信息A[8])
                情绪A = 0
                面子A = 0

            elif (敌人编号[2] == 'Nome'):
                if (敌人信息A[12] == '被攻击' or 敌人信息A[12] == '#'):
                    printx(f'[{名字}]向[{敌人信息A[0]}]与[{敌人信息B[0]}]发起了战斗', 0.1)
                if (敌人信息A[12] == '攻击'):
                    printx(f'[{名字}]遭遇[{敌人信息A[0]}]与[{敌人信息B[0]}]的战斗', 0.1)
                if (敌人信息A[12] == '路过'):
                    printx(f'[{敌人信息A[0]}]与[{敌人信息B[0]}]路过你身边...', 0.1)
                
                血量A = int(敌人信息A[5])
                血量A上限 = int(敌人信息A[5])
                攻击A = int(敌人信息A[6])
                防御A = int(敌人信息A[7])
                内力值A上限 = int(敌人信息A[8])
                内力值A = int(敌人信息A[8])
                情绪A = 0
                面子A = 0
                血量B = int(敌人信息B[5])
                血量B上限 = int(敌人信息A[5])
                攻击B = int(敌人信息B[6])
                防御B = int(敌人信息B[7])
                内力值B上限 = int(敌人信息B[8])
                内力值B = int(敌人信息B[8])
                情绪B = 0
                面子B = 0
            else:
                if (敌人信息A[12] == '被攻击' or 敌人信息A[12] == '#'):
                    printx(f'[{名字}]向[{敌人信息A[0]}]与[{敌人信息B[0]}]和[{敌人信息C[0]}]发起了战斗', 0.1)
                if (敌人信息A[12] == '攻击'):
                    printx(f'[{名字}]遭遇[{敌人信息A[0]}]与[{敌人信息B[0]}]和[{敌人信息C[0]}]的战斗', 0.1)
                if (敌人信息A[12] == '路过'):
                    printx(f'[{敌人信息A[0]}]与[{敌人信息B[0]}]和[{敌人信息C[0]}]路过你身边...', 0.1)
                
                血量A = int(敌人信息A[5])
                血量A上限 = int(敌人信息A[5])
                攻击A = int(敌人信息A[6])
                防御A = int(敌人信息A[7])
                内力值A上限 = int(敌人信息A[8])
                内力值A = int(敌人信息A[8])
                情绪A = 0
                面子A = 0
                血量B = int(敌人信息B[5])
                血量B上限 = int(敌人信息A[5])
                攻击B = int(敌人信息B[6])
                防御B = int(敌人信息B[7])
                内力值B上限 = int(敌人信息B[8])
                内力值B = int(敌人信息B[8])
                情绪B = 0
                面子B = 0
                血量C = int(敌人信息C[5])
                血量C上限 = int(敌人信息A[5])
                攻击C = int(敌人信息C[6])
                防御C = int(敌人信息C[7])
                内力值C上限 = int(敌人信息C[8])
                内力值C = int(敌人信息C[8])
                情绪C = 0
                面子C = 0

            回合数 = 1
            状态A = ['良好']
            状态B = ['良好']
            状态C = ['良好']
            情绪A = 0
            面子B = 0
            情绪B = 0
            面子C = 0
            情绪C = 0
            面子C = 0
            折磨次数A = 0
            折磨次数B = 0
            折磨次数C = 0
            中毒血量程度A = 2
            中毒血量程度B = 2
            中毒血量程度C = 2
            # 整理我方技能信息
            玩家的技能信息储存_整理A = 技能信息列表[玩家的技能信息储存[0]]
            玩家的技能信息储存_整理A = 玩家的技能信息储存_整理A.split(',')
            玩家的技能信息储存_整理B = 技能信息列表[玩家的技能信息储存[1]]
            玩家的技能信息储存_整理B = 玩家的技能信息储存_整理B.split(',')
            玩家的技能信息储存_整理C = 技能信息列表[玩家的技能信息储存[2]]
            玩家的技能信息储存_整理C = 玩家的技能信息储存_整理C.split(',')
            玩家的技能信息储存_整理D = 技能信息列表[玩家的技能信息储存[3]]
            玩家的技能信息储存_整理D = 玩家的技能信息储存_整理D.split(',')

            技能名称储存 = [玩家的技能信息储存_整理A[0],玩家的技能信息储存_整理B[0],玩家的技能信息储存_整理C[0],玩家的技能信息储存_整理D[0]]
            技能攻击储存 = [玩家的技能信息储存_整理A[1],玩家的技能信息储存_整理B[1],玩家的技能信息储存_整理C[1],玩家的技能信息储存_整理D[1]]
            破伤数据储存 = [玩家的技能信息储存_整理A[2],玩家的技能信息储存_整理B[2],玩家的技能信息储存_整理C[2],玩家的技能信息储存_整理D[2]]
            内力消耗储存 = [玩家的技能信息储存_整理A[3],玩家的技能信息储存_整理B[3],玩家的技能信息储存_整理C[3],玩家的技能信息储存_整理D[3]]
            攻击成功几率储存 = [玩家的技能信息储存_整理A[4],玩家的技能信息储存_整理B[4],玩家的技能信息储存_整理C[4],玩家的技能信息储存_整理D[4]]
            特殊说明储存 = [玩家的技能信息储存_整理A[5],玩家的技能信息储存_整理B[5],玩家的技能信息储存_整理C[5],玩家的技能信息储存_整理D[5]]
            特殊变量储存 = [玩家的技能信息储存_整理A[6],玩家的技能信息储存_整理B[6],玩家的技能信息储存_整理C[6],玩家的技能信息储存_整理D[6]]
            # 整理敌方技能信息
            if (not 敌人编号[0] == 'Nome'):
                玩家的技能信息储存_整理A = 技能信息列表[int(敌人信息A[1])]
                玩家的技能信息储存_整理A = 玩家的技能信息储存_整理A.split(',')
                玩家的技能信息储存_整理B = 技能信息列表[int(敌人信息A[2])]
                玩家的技能信息储存_整理B = 玩家的技能信息储存_整理B.split(',')
                玩家的技能信息储存_整理C = 技能信息列表[int(敌人信息A[3])]
                玩家的技能信息储存_整理C = 玩家的技能信息储存_整理C.split(',')
                玩家的技能信息储存_整理D = 技能信息列表[int(敌人信息A[4])]
                玩家的技能信息储存_整理D = 玩家的技能信息储存_整理D.split(',')

                技能名称储存A = [玩家的技能信息储存_整理A[0],玩家的技能信息储存_整理B[0],玩家的技能信息储存_整理C[0],玩家的技能信息储存_整理D[0]]
                技能攻击储存A = [玩家的技能信息储存_整理A[1],玩家的技能信息储存_整理B[1],玩家的技能信息储存_整理C[1],玩家的技能信息储存_整理D[1]]
                破伤数据储存A = [玩家的技能信息储存_整理A[2],玩家的技能信息储存_整理B[2],玩家的技能信息储存_整理C[2],玩家的技能信息储存_整理D[2]]
                内力消耗储存A = [玩家的技能信息储存_整理A[3],玩家的技能信息储存_整理B[3],玩家的技能信息储存_整理C[3],玩家的技能信息储存_整理D[3]]
                攻击成功几率储存A = [玩家的技能信息储存_整理A[4],玩家的技能信息储存_整理B[4],玩家的技能信息储存_整理C[4],玩家的技能信息储存_整理D[4]]
                特殊说明储存A = [玩家的技能信息储存_整理A[5],玩家的技能信息储存_整理B[5],玩家的技能信息储存_整理C[5],玩家的技能信息储存_整理D[5]]
                特殊变量储存A = [玩家的技能信息储存_整理A[6],玩家的技能信息储存_整理B[6],玩家的技能信息储存_整理C[6],玩家的技能信息储存_整理D[6]]

                敌人AI信息A = 敌人AI信息列表[int(敌人编号[0])]
                敌人AI信息A = 敌人AI信息A.split(',')

                武器A = int(敌人信息A[18])
                查看的选项 = 物品信息列表[武器A]
                查看的选项 = 查看的选项.split(',')
                if (not 武器A == 0):
                    攻击A = int(查看的选项[3]) + 攻击A

                防具A = int(敌人信息A[19])
                查看的选项 = 物品信息列表[防具A]
                查看的选项 = 查看的选项.split(',')
                if (not 防具A == 0):
                    防御B = int(查看的选项[3]) + 防御A

                护符A = int(敌人信息A[20])
                查看的选项 = 物品信息列表[护符A]
                查看的选项 = 查看的选项.split(',')
                免疫状态A = '-'
                if (not 护符A == 0):
                    免疫状态A = 查看的选项[3]

            if (not 敌人编号[1] == 'Nome'):
                玩家的技能信息储存_整理A = 技能信息列表[int(敌人信息B[1])]
                玩家的技能信息储存_整理A = 玩家的技能信息储存_整理A.split(',')
                玩家的技能信息储存_整理B = 技能信息列表[int(敌人信息B[2])]
                玩家的技能信息储存_整理B = 玩家的技能信息储存_整理B.split(',')
                玩家的技能信息储存_整理C = 技能信息列表[int(敌人信息B[3])]
                玩家的技能信息储存_整理C = 玩家的技能信息储存_整理C.split(',')
                玩家的技能信息储存_整理D = 技能信息列表[int(敌人信息B[4])]
                玩家的技能信息储存_整理D = 玩家的技能信息储存_整理D.split(',')

                技能名称储存B = [玩家的技能信息储存_整理A[0],玩家的技能信息储存_整理B[0],玩家的技能信息储存_整理C[0],玩家的技能信息储存_整理D[0]]
                技能攻击储存B = [玩家的技能信息储存_整理A[1],玩家的技能信息储存_整理B[1],玩家的技能信息储存_整理C[1],玩家的技能信息储存_整理D[1]]
                破伤数据储存B = [玩家的技能信息储存_整理A[2],玩家的技能信息储存_整理B[2],玩家的技能信息储存_整理C[2],玩家的技能信息储存_整理D[2]]
                内力消耗储存B = [玩家的技能信息储存_整理A[3],玩家的技能信息储存_整理B[3],玩家的技能信息储存_整理C[3],玩家的技能信息储存_整理D[3]]
                攻击成功几率储存B = [玩家的技能信息储存_整理A[4],玩家的技能信息储存_整理B[4],玩家的技能信息储存_整理C[4],玩家的技能信息储存_整理D[4]]
                特殊说明储存B = [玩家的技能信息储存_整理A[5],玩家的技能信息储存_整理B[5],玩家的技能信息储存_整理C[5],玩家的技能信息储存_整理D[5]]
                特殊变量储存B = [玩家的技能信息储存_整理A[6],玩家的技能信息储存_整理B[6],玩家的技能信息储存_整理C[6],玩家的技能信息储存_整理D[6]]
                敌人AI信息B = 敌人AI信息列表[int(敌人编号[1])]
                敌人AI信息B = 敌人AI信息B.split(',')

                武器B = int(敌人信息B[18])
                查看的选项 = 物品信息列表[武器B]
                查看的选项 = 查看的选项.split(',')
                if (not 武器B == 0):
                    攻击B = int(查看的选项[3]) + 攻击B

                防具B = int(敌人信息B[19])
                查看的选项 = 物品信息列表[防具B]
                查看的选项 = 查看的选项.split(',')
                if (not 防具B == 0):
                    防御B = int(查看的选项[3]) + 防御B

                护符B = int(敌人信息B[20])
                查看的选项 = 物品信息列表[护符B]
                查看的选项 = 查看的选项.split(',')
                免疫状态B = '-'
                if (not 护符B == 0):
                    免疫状态B = 查看的选项[3]

            if (not 敌人编号[2] == 'Nome'):
                玩家的技能信息储存_整理A = 技能信息列表[int(敌人信息C[1])]
                玩家的技能信息储存_整理A = 玩家的技能信息储存_整理A.split(',')
                玩家的技能信息储存_整理B = 技能信息列表[int(敌人信息C[2])]
                玩家的技能信息储存_整理B = 玩家的技能信息储存_整理B.split(',')
                玩家的技能信息储存_整理C = 技能信息列表[int(敌人信息C[3])]
                玩家的技能信息储存_整理C = 玩家的技能信息储存_整理C.split(',')
                玩家的技能信息储存_整理D = 技能信息列表[int(敌人信息C[4])]
                玩家的技能信息储存_整理D = 玩家的技能信息储存_整理D.split(',')

                技能名称储存C = [玩家的技能信息储存_整理A[0],玩家的技能信息储存_整理B[0],玩家的技能信息储存_整理C[0],玩家的技能信息储存_整理D[0]]
                技能攻击储存C = [玩家的技能信息储存_整理A[1],玩家的技能信息储存_整理B[1],玩家的技能信息储存_整理C[1],玩家的技能信息储存_整理D[1]]
                破伤数据储存C = [玩家的技能信息储存_整理A[2],玩家的技能信息储存_整理B[2],玩家的技能信息储存_整理C[2],玩家的技能信息储存_整理D[2]]
                内力消耗储存C = [玩家的技能信息储存_整理A[3],玩家的技能信息储存_整理B[3],玩家的技能信息储存_整理C[3],玩家的技能信息储存_整理D[3]]
                攻击成功几率储存C = [玩家的技能信息储存_整理A[4],玩家的技能信息储存_整理B[4],玩家的技能信息储存_整理C[4],玩家的技能信息储存_整理D[4]]
                特殊说明储存C = [玩家的技能信息储存_整理A[5],玩家的技能信息储存_整理B[5],玩家的技能信息储存_整理C[5],玩家的技能信息储存_整理D[5]]
                特殊变量储存C = [玩家的技能信息储存_整理A[6],玩家的技能信息储存_整理B[6],玩家的技能信息储存_整理C[6],玩家的技能信息储存_整理D[6]]
                敌人AI信息C = 敌人AI信息列表[int(敌人编号[2])]
                敌人AI信息C = 敌人AI信息C.split(',')

                武器C = int(敌人信息C[18])
                查看的选项 = 物品信息列表[武器C]
                查看的选项 = 查看的选项.split(',')
                if (not 武器C == 0):
                    攻击C = int(查看的选项[3]) + 攻击C

                防具C = int(敌人信息C[19])
                查看的选项 = 物品信息列表[防具C]
                查看的选项 = 查看的选项.split(',')
                if (not 防具C == 0):
                    防御B = int(查看的选项[3]) + 防御C

                护符C = int(敌人信息C[20])
                查看的选项 = 物品信息列表[护符C]
                查看的选项 = 查看的选项.split(',')
                免疫状态C = '-'
                if (not 护符C == 0):
                    免疫状态C = 查看的选项[3]

            # 初始我方状态
            # 战士：#-# @w@ 辅助员：正义的最强大爷 &-% 移动商店：$v$ 武器升级：&-^
            等级 = 1
            for __count in range(100):
                if (经验 >= 等级 * 50):
                    等级 += 1

            队友B等级 = 1
            for __count in range(100):
                if (经验 >= 队友B等级 * 50):
                    队友B等级 += 1

            队友C等级 = 1
            for __count in range(100):
                if (经验 >= 队友C等级 * 50):
                    队友C等级 += 1

            血量上限 = (等级*5 +45)
            血量 = (等级*5 +45)
            内力值上限 = (等级*3 +2)
            内力值 = (等级*3 +2)
            状态 = ['良好']
            攻击 = (等级*3 + 3)
            防御 = (等级*2 + 2)
            死亡后可回复的血量 = (等级 + 2)
            免疫状态 = '-'
            中毒血量程度 = 2

            队友B血量上限 = (队友B等级*5 +55)
            队友B血量 = (队友B等级*5 +55)
            队友B内力值上限 = (队友B等级*3 +2)
            队友B内力值 = (队友B等级*3 +2)
            队友B状态 = ['良好']
            队友B攻击 = (队友B等级*3)
            队友B防御 = (队友B等级*2 + 1)
            死亡后可回复的血量B = (等级 + 1)
            队友B免疫状态 = '-'
            队友B中毒血量程度 = 2

            队友C血量上限 = (队友C等级*5 +35)
            队友C血量 = (队友C等级*5 +35)
            队友C内力值上限 = (队友C等级*3 +7)
            队友C内力值 = (队友C等级*3 +7)
            队友C状态 = ['良好']
            队友C攻击 = (队友C等级*3 + 1)
            队友C防御 = (队友C等级*2 + 4)
            死亡后可回复的血量C = (等级 + 3)
            队友C免疫状态 = '-'
            队友C中毒血量程度 = 2

            # 装备信息加入
            查看的选项 = 物品信息列表[武器]
            查看的选项 = 查看的选项.split(',')
            if (not 武器 == 0):
                攻击 = int(查看的选项[3]) + 攻击

            查看的选项 = 物品信息列表[防具]
            查看的选项 = 查看的选项.split(',')
            if (not 防具 == 0):
                防御 = int(查看的选项[3]) + 防御

            查看的选项 = 物品信息列表[护符]
            查看的选项 = 查看的选项.split(',')
            if (not 护符 == 0):
                免疫状态 = 查看的选项[3]
            
            if (not 敌人编号[0] == 'Nome' and 敌人信息A[12] == '被攻击'):
                printx(敌人AI信息A[3],0.1)

            if (not 敌人编号[1] == 'Nome' and 敌人信息B[12] == '被攻击'):
                printx(敌人AI信息B[3],0.1)
            
            if (not 敌人编号[2] == 'Nome' and 敌人信息C[12] == '被攻击'):
                printx(敌人AI信息C[3], 0.1)

            if (not 敌人编号[0] == 'Nome' and 敌人信息A[12] == '路过'):
                printx(敌人AI信息A[8],0.1)

            if (not 敌人编号[1] == 'Nome' and 敌人信息B[12] == '路过'):
                printx(敌人AI信息B[8],0.1)
            
            if (not 敌人编号[2] == 'Nome' and 敌人信息C[12] == '路过'):
                printx(敌人AI信息C[8], 0.1)

            while True:
                是否无法攻击 = 0
                是否无法攻击A = 0
                是否无法攻击B = 0
                是否无法攻击C = 0
                if ('烧伤一品' in 状态):
                    血量 -= 10
                    printx(f'[{名字}]因烧伤血量减少10',0.1)

                if ('烧伤二品' in 状态):
                    血量 -= 20
                    printx(f'[{名字}]因烧伤血量减少20',0.1)

                if ('烧伤三品' in 状态):
                    血量 -= 30
                    printx(f'[{名字}]因烧伤血量减少30',0.1)

                if ('烧伤一品' in 状态A):
                    血量A -= 10
                    printx(f'[[{敌人信息A[0]}]因烧伤血量减少10',0.1)

                if ('烧伤二品' in 状态A):
                    血量A -= 20
                    printx(f'[{敌人信息A[0]}]因烧伤血量减少20',0.1)

                if ('烧伤三品' in 状态A):
                    血量A -= 30
                    printx(f'[{敌人信息A[0]}]因烧伤血量减少30',0.1)
                    
                if ('烧伤一品' in 状态B):
                    血量B -= 10
                    printx(f'[{敌人信息B[0]}]因烧伤血量减少10',0.1)

                if ('烧伤二品' in 状态B):
                    血量B -= 20
                    printx(f'[{敌人信息B[0]}]因烧伤血量减少20',0.1)

                if ('烧伤三品' in 状态B):
                    血量B -= 30
                    printx(f'[{敌人信息B[0]}]因烧伤血量减少30',0.1)

                if ('烧伤一品' in 状态C):
                    血量C -= 10
                    printx(f'[{敌人信息C[0]}]因烧伤血量减少10',0.1)

                if ('烧伤二品' in 状态C):
                    血量C -= 20
                    printx(f'[{敌人信息C[0]}]因烧伤血量减少20',0.1)

                if ('烧伤三品' in 状态C):
                    血量C -= 30
                    printx(f'[{敌人信息C[0]}]因烧伤血量减少30',0.1)
                

                if ('中毒一品' in 状态):
                    血量 -= 中毒血量程度
                    printx(f'[{名字}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 2

                if ('中毒二品' in 状态):
                    血量 -= 中毒血量程度
                    printx(f'[{名字}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 6

                if ('中毒三品' in 状态):
                    血量 -= 中毒血量程度
                    printx(f'[{名字}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 10

                if ('中毒一品' in 状态A):
                    血量A -= 中毒血量程度A
                    printx(f'[[{敌人信息A[0]}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 2

                if ('中毒二品' in 状态A):
                    血量A -= 中毒血量程度A
                    printx(f'[{敌人信息A[0]}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 6

                if ('中毒三品' in 状态A):
                    血量A -= 中毒血量程度A
                    printx(f'[{敌人信息A[0]}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 10
                    
                if ('中毒一品' in 状态B):
                    血量B -= 中毒血量程度B
                    printx(f'[{敌人信息B[0]}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 2

                if ('中毒二品' in 状态B):
                    血量B -= 中毒血量程度B
                    printx(f'[{敌人信息B[0]}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 6

                if ('中毒三品' in 状态B):
                    血量B -=中毒血量程度B
                    printx(f'[{敌人信息B[0]}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 10

                if ('中毒一品' in 状态C):
                    血量C -= 中毒血量程度C
                    printx(f'[{敌人信息C[0]}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 2

                if ('中毒二品' in 状态C):
                    血量C -= 中毒血量程度C
                    printx(f'[{敌人信息C[0]}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 6

                if ('中毒三品' in 状态C):
                    血量C -= 中毒血量程度C
                    printx(f'[{敌人信息C[0]}]因中毒血量减少{中毒血量程度}',0.1)
                    中毒血量程度 += 10
                    
                if ('麻痹一品' in 状态):
                    if (random.randint(1, 5) == 1):
                        是否无法攻击 = 1
                        printx(f'[{名字}]因麻痹本回合无法攻击!!',0.1)

                if ('麻痹二品' in 状态):
                    if (random.randint(1, 3) == 1):
                        是否无法攻击 = 1
                        printx(f'[{名字}]因麻痹本回合无法攻击!!',0.1)

                if ('麻痹三品' in 状态):
                    if (random.randint(1, 2) == 1):
                        是否无法攻击 = 1
                        printx(f'[{名字}]因麻痹本回合无法攻击!!',0.1)

                if ('麻痹一品' in 状态A):
                    是否无法攻击A = 1
                    if (random.randint(1, 5) == 1):
                        printx(f'[{敌人信息A[0]}]因麻痹本回合无法攻击!!',0.1)

                if ('麻痹二品' in 状态A):
                    if (random.randint(1, 3) == 1):
                        是否无法攻击A = 1
                        printx(f'[{敌人信息A[0]}]因麻痹本回合无法攻击!!',0.1)

                if ('麻痹三品' in 状态A):
                    if (random.randint(1, 2) == 1):
                        是否无法攻击A = 1
                        printx(f'[{敌人信息A[0]}]因麻痹本回合无法攻击!!',0.1)
                    
                if ('麻痹一品' in 状态B):
                    if (random.randint(1, 5) == 1):
                        是否无法攻击B = 1
                        printx(f'[{敌人信息B[0]}]因麻痹本回合无法攻击!!',0.1)

                if ('麻痹二品' in 状态B):
                    if (random.randint(1, 3) == 1):
                        是否无法攻击B = 1
                        printx(f'[{敌人信息B[0]}]因麻痹本回合无法攻击!!',0.1)

                if ('麻痹三品' in 状态B):
                    if (random.randint(1, 2) == 1):
                        是否无法攻击B = 1
                        printx(f'[{敌人信息B[0]}]因麻痹本回合无法攻击!!',0.1)

                if ('麻痹一品' in 状态C):
                    if (random.randint(1, 5) == 1):
                        是否无法攻击C = 1
                        printx(f'[{敌人信息C[0]}]因麻痹本回合无法攻击!!',0.1)

                if ('麻痹二品' in 状态C):
                    if (random.randint(1, 3) == 1):
                        是否无法攻击C = 1
                        printx(f'[{敌人信息C[0]}]因麻痹本回合无法攻击!!',0.1)

                if ('麻痹三品' in 状态C):
                    if (random.randint(1, 2) == 1):
                        是否无法攻击C = 1
                        printx(f'[{敌人信息C[0]}]因麻痹本回合无法攻击!!',0.1)

                if ('中邪一品' in 状态):
                    if (random.randint(1, 7) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存[失去技能编号] = '----'
                        printx(f'[{名字}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)

                if ('中邪二品' in 状态):
                    if (random.randint(1, 5) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存[失去技能编号] = '----'
                        printx(f'[{名字}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)

                if ('中邪三品' in 状态):
                    if (random.randint(1, 3) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存[失去技能编号] = '----'
                        printx(f'[{名字}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)

                if ('中邪一品' in 状态A):
                    if (random.randint(1, 7) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存A[失去技能编号] = '----'
                        printx(f'[{敌人信息A[0]}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)

                if ('中邪二品' in 状态A):
                    if (random.randint(1, 5) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存A[失去技能编号] = '----'
                        printx(f'[{敌人信息A[0]}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)

                if ('中邪三品' in 状态A):
                    if (random.randint(1, 3) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存A[失去技能编号] = '----'
                        printx(f'[{敌人信息A[0]}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)

                if ('中邪一品' in 状态C):
                    if (random.randint(1, 7) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存C[失去技能编号] = '----'
                        printx(f'[{敌人信息C[0]}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)

                if ('中邪二品' in 状态C):
                    if (random.randint(1, 5) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存C[失去技能编号] = '----'
                        printx(f'[{敌人信息C[0]}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)

                if ('中邪三品' in 状态C):
                    if (random.randint(1, 3) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存C[失去技能编号] = '----'
                        printx(f'[{敌人信息C[0]}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)

                if ('中邪一品' in 状态C):
                    if (random.randint(1, 7) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存C[失去技能编号] = '----'
                        printx(f'[{敌人信息C[0]}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)

                if ('中邪二品' in 状态C):
                    if (random.randint(1, 5) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存C[失去技能编号] = '----'
                        printx(f'[{敌人信息C[0]}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)

                if ('中邪三品' in 状态C):
                    if (random.randint(1, 3) == 1):
                        失去技能编号 = random.randint(0, 3)
                        while True:
                            if (not 技能名称储存[失去技能编号] == '----'):
                                break
                            else:
                                失去技能编号 = random.randint(0, 3)
                        技能名称储存C[失去技能编号] = '----'
                        printx(f'[{敌人信息C[0]}]因中邪[技能{失去技能编号+1}]无法使用了!!',0.1)
                # 状态攻击:烧伤(持续等量伤害) 中毒(逐渐提高伤害) 中邪(一定几率无法使用特定招数) 麻痹(一定几率无法使用招数)
                # 开心:情绪到达开心极限 伤心:路过/饶恕后被攻击两次以上 放松:[朋友]一次后 愤怒:被攻击/饶恕后被攻击两次以上后
                # 绝望:死亡之时 死亡:死亡 诧异:[朋友]一次后直接攻击 饶恕:饶恕
                if (not '烧伤一品' in 状态 and not '烧伤二品' in 状态 and not '烧伤三品' in 状态):
                    if (not '中毒一品' in 状态 and not '中毒二品' in 状态 and not '中毒三品' in 状态):
                        if (not '中邪一品' in 状态 and not '中邪二品' in 状态 and not '中邪三品' in 状态):
                            if (not '麻痹一品' in 状态 and not '麻痹二品' in 状态 and not '麻痹三品' in 状态):
                                if (not '良好' in 状态 and not '濒死' in 状态):
                                    状态.append('良好')

                if (not '烧伤一品' in 状态A and not '烧伤二品' in 状态A and not '烧伤三品' in 状态A):
                    if (not '中毒一品' in 状态A and not '中毒二品' in 状态A and not '中毒三品' in 状态A):
                        if (not '中邪一品' in 状态A and not '中邪二品' in 状态A and not '中邪三品' in 状态A):
                            if (not '麻痹一品' in 状态A and not '麻痹二品' in 状态A and not '麻痹三品' in 状态A):
                                if (not '良好' in 状态A and not '濒死' in 状态A):
                                    状态A.append('良好')

                if (not '烧伤一品' in 状态B and not '烧伤二品' in 状态B and not '烧伤三品' in 状态B):
                    if (not '中毒一品' in 状态B and not '中毒二品' in 状态B and not '中毒三品' in 状态B):
                        if (not '中邪一品' in 状态B and not '中邪二品' in 状态B and not '中邪三品' in 状态B):
                            if (not '麻痹一品' in 状态B and not '麻痹二品' in 状态B and not '麻痹三品' in 状态B):
                                if (not '良好' in 状态B and not '濒死' in 状态B):
                                    状态B.append('良好')
                
                if (not '烧伤一品' in 状态C and not '烧伤二品' in 状态C and not '烧伤三品' in 状态C):
                    if (not '中毒一品' in 状态C and not '中毒二品' in 状态C and not '中毒三品' in 状态C):
                        if (not '中邪一品' in 状态C and not '中邪二品' in 状态C and not '中邪三品' in 状态C):
                            if (not '麻痹一品' in 状态C and not '麻痹二品' in 状态C and not '麻痹三品' in 状态C):
                                if (not '良好' in 状态C and not '濒死' in 状态C):
                                    状态C.append('良好')

                if (not 敌人编号[0] == 'Nome'):
                    # 没面子
                    if (面子A >= int(敌人信息A[9])):
                        printx(敌人AI信息A[7],0.1)
                        if (not '饶恕' in 状态A):
                            状态A.append('饶恕')
                    # 害怕
                    if (情绪A <= int(敌人信息A[10])):
                        printx(敌人AI信息A[1],0.1)
                        防御A = 0
                        printx('[{敌人信息A[0]}]的防御力归零!!就趁现在!!',0.1)
                        if (not '饶恕' in 状态A):
                            状态A.append('饶恕')
                    # 路过求饶恕
                    if (血量A >= int(敌人信息A[21]) and 敌人信息A[12] == '路过' and not 折磨次数A > int(敌人信息A[22])):
                        防御A = 0
                        if (not '饶恕' in 状态A):
                            状态A.append('饶恕')
                        printx(f'[{敌人信息A[0]}]想要和平的结束这场战斗...',0.1)
                    # 说服
                    if (血量A >= 0 and 面子A >= int(敌人信息A[9])):
                        防御A = 0
                        if (not '饶恕' in 状态A):
                            状态A.append('饶恕')
                        printx(f'[{敌人信息A[0]}]被你说服了...', 0.1)

                    # 要完
                    if (血量A <= int(敌人信息A[21]) and 血量A > 0):
                        printx(敌人AI信息A[4],0.1)
                        if ('饶恕' in 状态A):
                            del 状态A[状态A.index('饶恕')]
                        if (敌人信息A[12] == '被攻击'):
                            printx(f'[{敌人信息A[0]}]想要和平与你交谈...', 0.1)
                            if (not '饶恕' in 状态A):
                                状态A.append('饶恕')

                    # 扑街！！
                    if (血量A <= 0):
                        if (not '濒死' in 状态A):
                            状态A.append('濒死')
                        printx(敌人AI信息A[5],0.1)
                        
                    # 开心啦
                    if (情绪A >= int(敌人信息A[11]) and '饶恕' in 状态A):
                        printx(敌人AI信息A[0], 0.1)

                    # 生气！！
                    if (折磨次数A > int(敌人信息A[22]) and not  '濒死' in 状态A):
                        printx(敌人AI信息A[3],0.1)
                        攻击A += int(敌人信息A[23])

                if (not 敌人编号[1] == 'Nome'):
                    if (血量B >= 0 and 面子B >= int(敌人信息B[9])):
                        防御B = 0
                        if (not '饶恕' in 状态B):
                            状态B.append('饶恕')
                        printx(f'[{敌人信息B[0]}]被你说服了...',0.1)

                    if (面子B >= int(敌人信息B[9])):
                        printx(敌人AI信息B[7],0.1)
                        if (not '饶恕' in 状态B):
                            状态B.append('饶恕')
                    if (情绪B <= int(敌人信息B[10])):
                        防御B = 0
                        printx(敌人AI信息B[1],0.1)
                        防御B = 0
                        printx('[{敌人信息B[0]}]的防御力归零!!就趁现在!!',0.1)
                        if (not '饶恕' in 状态B):
                            状态B.append('饶恕')

                    if (血量B >= int(敌人信息B[21]) and 敌人信息B[12] == '路过' and not 折磨次数B > int(敌人信息B[22])):
                        防御B = 0
                        if (not '饶恕' in 状态B):
                            状态B.append('饶恕')
                        printx(f'[{敌人信息B[0]}]想要和平的结束这场战斗...',0.1)

                    if (血量B <= int(敌人信息B[21]) and 血量B > 0):
                        printx(敌人AI信息B[4], 0.1)
                        if ('饶恕' in 状态B):
                            del 状态B[状态B.index('饶恕')]
                        if (敌人信息B[12] == '被攻击'):
                            printx(f'[{敌人信息B[0]}]想要和平与你交谈...', 0.1)
                            if (not '饶恕' in 状态B):
                                状态B.append('饶恕')

                    if (血量B <= 0):
                        if (not '濒死' in 状态B):
                            状态B.append('濒死')
                        printx(敌人AI信息B[5],0.1)
                        if ('良好' in 状态B):
                            del 状态B[状态B.index('良好')]
                        if ('饶恕' in 状态B):
                            del 状态B[状态B.index('饶恕')]
                        
                            
                    if (情绪B >= int(敌人信息B[11]) and '饶恕' in 状态B):
                        printx(敌人AI信息B[0], 0.1)

                    if (折磨次数B > int(敌人信息B[22]) and not  '濒死' in 状态B):
                        printx(敌人AI信息B[3],0.1)
                        攻击B += 2

                if (not 敌人编号[2] == 'Nome'):
                    if (血量C >= 0 and 面子C >= int(敌人信息C[9])):
                        防御C = 0
                        if (not '饶恕' in 状态C):
                            状态C.append('饶恕')
                        printx(f'[{敌人信息C[0]}]被你说服了...',0.1)

                    if (面子C >= int(敌人信息C[9])):
                        printx(敌人AI信息C[7],0.1)
                        if (not '饶恕' in 状态C):
                            状态C.append('饶恕')

                    if (情绪C <= int(敌人信息C[10])):
                        防御C = 0
                        printx(敌人AI信息C[1],0.1)
                        防御C = 0
                        printx('[{敌人信息C[0]}]的防御力归零!!就趁现在!!',0.1)
                        if (not '饶恕' in 状态C):
                            状态C.append('饶恕')

                    if (血量C >= int(敌人信息C[21]) and 敌人信息C[12] == '路过' and not 折磨次数C > int(敌人信息C[22])):
                        防御C = 0
                        if (not '饶恕' in 状态C):
                            状态C.append('饶恕')
                        printx(f'[{敌人信息C[0]}]想要和平的结束这场战斗...',0.1)

                    if (血量C <= int(敌人信息C[21]) and 血量C > 0):
                        printx(敌人AI信息A[4],0.1)
                        if ('饶恕' in 状态C):
                            del 状态C[状态C.index('饶恕')]
                        if (敌人信息C[12] == '被攻击'):
                            printx(f'[{敌人信息C[0]}]想要和平与你交谈...', 0.1)
                            if (not '饶恕' in 状态C):
                                状态C.append('饶恕')

                    if (血量C <= 0):
                        if (not '濒死' in 状态C):
                            状态C.append('濒死')
                        printx(敌人AI信息C[5],0.1)
                        if ('良好' in 状态C):
                            del 状态C[状态C.index('良好')]
                        if ('饶恕' in 状态C):
                            del 状态C[状态C.index('饶恕')]

                    if (情绪C >= int(敌人信息C[11]) and '饶恕' in 状态C):
                        printx(敌人AI信息C[0], 0.1)

                    if (折磨次数C > int(敌人信息C[22]) and not  '濒死' in 状态C):
                        printx(敌人AI信息C[3],0.1)
                        攻击C += 2
                
                if('濒死' in 状态A and not int(敌人信息A[23]) == 0):
                    血量A += int(敌人信息A[22])
                    printx(f'[{敌人信息A[0]}]回复了{int(敌人信息A[22])}血量', 0.1)
                
                if('濒死' in 状态B and not int(敌人信息B[23]) == 0):
                    血量B += int(敌人信息B[22])
                    printx(f'[{敌人信息B[0]}]回复了{int(敌人信息B[22])}血量', 0.1)

                if('濒死' in 状态C and not int(敌人信息C[23]) == 0):
                    血量C += int(敌人信息C[22])
                    printx(f'[{敌人信息C[0]}]回复了{int(敌人信息C[22])}血量', 0.1)

                if (血量 <= 0):
                    printx(f'[{名字}]倒下了..',0.1)
                    if (not '濒死' in 状态):
                        状态.append('濒死')

                if ('濒死' in 状态):
                    血量 += 死亡后可回复的血量
                    printx(f'[{名字}]回复了{死亡后可回复的血量}血量', 0.1)
                # 记得添加队友！！

                if (敌人编号[1] == 'Nome'):
                    if('濒死' in 状态A):
                        人物死亡名称列表.append(敌人信息A[0])
                        杀死敌人数量 += 1
                        胜利条件 = '杀死'
                        break
                elif (敌人编号[2] == 'Nome'):
                    if('濒死' in 状态A and '濒死' in 状态B):
                        人物死亡名称列表.append(敌人信息A[0])
                        人物死亡名称列表.append(敌人信息B[0])
                        杀死敌人数量 += 2
                        胜利条件 = '杀死'
                        break
                else:
                    if('濒死' in 状态A and '濒死' in 状态B and '濒死' in 状态C):
                        人物死亡名称列表.append(敌人信息A[0])
                        人物死亡名称列表.append(敌人信息B[0])
                        人物死亡名称列表.append(敌人信息C[0])
                        杀死敌人数量 += 3
                        胜利条件 = '杀死'
                        break

                if (敌人编号[1] == 'Nome'):
                    if('饶恕' in 状态A):
                        printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                elif (敌人编号[2] == 'Nome'):
                    if('饶恕' in 状态A and '饶恕' in 状态B):
                        printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                    if('濒死' in 状态A and '饶恕' in 状态B):
                        printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                    if('饶恕' in 状态A and '濒死' in 状态B):
                        printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                else:
                    if('饶恕' in 状态A and '饶恕' in 状态B and '饶恕' in 状态C):
                        printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                    if('濒死' in 状态A and '饶恕' in 状态B and '饶恕' in 状态C):
                        printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                    if('饶恕' in 状态A and '濒死' in 状态B and '饶恕' in 状态C):
                        printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                    if('饶恕' in 状态A and '饶恕' in 状态B and '濒死' in 状态C):
                        printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                    if('濒死' in 状态A and '濒死' in 状态B and '饶恕' in 状态C):
                        printx('现在你可以选择[4]来原谅你的敌人了',0.1)
                    if('饶恕' in 状态A and '濒死' in 状态B and '濒死' in 状态C):
                        printx('现在你可以选择[4]来原谅你的敌人了', 0.1)

                回答 = ''
                print(f'@-----------第{回合数}回合-----------@')
                sleep(0.05)
                if (敌人编号[1] == 'Nome'):
                    print(f'{敌人信息A[0]} 血量:{血量A} 状态:{状态A}')
                elif (敌人编号[2] == 'Nome'):
                    print(f'{敌人信息A[0]} 血量:{血量A} 状态:{状态A}')
                    sleep(0.05)
                    print(f'{敌人信息B[0]} 血量:{血量B} 状态:{状态B}')
                else:
                    print(f'{敌人信息A[0]} 血量:{血量A} 状态:{状态A}')
                    sleep(0.05)
                    print(f'{敌人信息B[0]} 血量:{血量B} 状态:{状态B}')
                    sleep(0.05)
                    print(f'{敌人信息C[0]} 血量:{血量C} 状态:{状态C}')
                sleep(0.05)
                print('@-------------我方------------@')
                sleep(0.05)
                print(f'{名字} 血量:{血量} 状态:{状态}')
                sleep(0.05)
                if (队友数量 > 1):
                    print(f'#-# 血量:{队友B血量} 状态:{队友B状态}')
                    sleep(0.05)
                if (队友数量 > 2):
                    print(f'@w@ 血量:{队友C血量} 状态:{队友C状态}')
                    sleep(0.05)
                if (是否无法攻击 == 0):
                    print(f'@-----------指挥玩家----------@')
                    sleep(0.05)
                    print('1.出招 2.行动')
                    sleep(0.05)
                    print('3.背包 4.原谅')
                    sleep(0.05)
                    if (敌人信息A[0] == '无名:空梦'):
                        while True:
                            if (回答 == '1' or 回答 == '3'):
                                break
                            else:
                                回答 = input("输入操作 >>> ")
                    else:
                        while True:
                            if (回答 == '1' or 回答 == '2' or 回答 == '3' or 回答 == '4'):
                                break
                            else:
                                回答 = input("输入操作 >>> ")

                    if (回答 == '1'):
                        print('@-------------出招------------@')
                        printx('选择要对其使用对象',0.1)
                        sleep(0.05)
                        if (敌人编号[1] == 'Nome'):
                            print(f'1.{名字} 2.{敌人信息A[0]}')
                        elif (敌人编号[2] == 'Nome'):
                            print(f'1.{名字} 2.{敌人信息A[0]} 3.{敌人信息B[0]}')
                        else:
                            print(f'1.{名字} 2.{敌人信息A[0]} 3.{敌人信息B[0]} 4.{敌人信息C[0]}')
                        sleep(0.05)
                        攻击对象 = ''
                        while True:
                            if (攻击对象 == '1'):
                                break
                            if (攻击对象 == '2' and not 敌人编号[0] == 'Nome'):
                                break
                            if (攻击对象 == '3' and not 敌人编号[1] == 'Nome'):
                                break
                            if (攻击对象 == '4' and not 敌人编号[2] == 'Nome'):
                                break
                            else:
                                攻击对象 = input("输入操作 >>> ")
                        print(f'O-----------选择技能----------O')
                        sleep(0.05)
                        print(f'{名字} 内力值:{内力值}')
                        sleep(0.05)
                        print(f'1.{技能名称储存[0]}[内力{内力消耗储存[0]}] 2.{技能名称储存[1]}[内力{内力消耗储存[1]}]')
                        sleep(0.05)
                        print(
                            f'3.{技能名称储存[2]}[内力{内力消耗储存[2]}] 4.{技能名称储存[3]}[内力{内力消耗储存[3]}]')
                        sleep(0.05)
                        回答 = ''
                        while True:
                            if (回答 == '1' and not 技能名称储存[0] == '----'):
                                回答 = int(回答)
                                if (内力值 - int(内力消耗储存[(回答 - 1)]) > -1):
                                    break
                                else:
                                    printx('所需内力消耗值不足!!请重新选择',0.1)
                                回答 = ''
                            if (回答 == '2' and not 技能名称储存[1] == '----'):
                                回答 = int(回答)
                                if (内力值 - int(内力消耗储存[(回答 - 1)]) > -1):
                                    break
                                else:
                                    printx('所需内力消耗值不足!!请重新选择', 0.1)
                                回答 = ''
                            if (回答 == '3' and not 技能名称储存[2] == '----'):
                                回答 = int(回答)
                                if (内力值 - int(内力消耗储存[(回答 - 1)]) > -1):
                                    break
                                else:
                                    printx('所需内力消耗值不足!!请重新选择', 0.1)
                                回答 = ''
                            if (回答 == '4' and not 技能名称储存[3] == '----'):
                                回答 = int(回答)
                                if (内力值 - int(内力消耗储存[(回答 - 1)]) > -1):
                                    break
                                else:
                                    printx('所需内力消耗值不足!!请重新选择', 0.1)
                                回答 = ''
                            else:
                                回答 = input("输入操作 >>> ")
                
                        print(f'O-----------我方回合----------O')
                        printx(f'[{名字}]的回合:',0.1)
                        if ('一' in 特殊变量储存[回答-1]):
                            状态等级 = 1
                        if ('二' in 特殊变量储存[回答-1]):
                            状态等级 = 2
                        if ('三' in 特殊变量储存[回答-1]):
                            状态等级 = 3

                        内力值 -= int(内力消耗储存[回答-1])
                        if (攻击对象 == '1'):
                            printx(f'[{名字}]对[{名字}]使用了[{技能名称储存[回答-1]}]????', 0.1)
                        if (攻击对象 == '2'):
                            printx(f'[{名字}]对[{敌人信息A[0]}]使用了[{技能名称储存[回答-1]}]', 0.1)
                            if('饶恕' in 状态A or 情绪A > 0):
                                if (not 折磨次数A >= int(敌人信息A[22])):
                                    防御A -= 5
                                    printx(敌人AI信息A[6], 0.1)
                                    printx(f'[{敌人信息A[0]}]的防御迅速减少!!',0.1)
                                    折磨次数A += 1
                                else:
                                    折磨次数A += 1
                                    情绪A = 0
                                    printx(敌人AI信息A[1], 0.1)
                                    if ('饶恕' in 状态A):
                                        del 状态A[状态A.index("饶恕")]
                        if (攻击对象 == '3'):
                            printx(f'[{名字}]对[{敌人信息B[0]}]使用了[{技能名称储存[回答-1]}]', 0.1)
                            if('饶恕' in 状态B or 情绪B > 0):
                                if (not 折磨次数B >= int(敌人信息B[22])):
                                    防御B -= 5
                                    printx(敌人AI信息B[6], 0.1)
                                    printx(f'[{敌人信息B[0]}]的防御迅速减少!!',0.1)
                                    折磨次数B += 1
                                else:
                                    折磨次数B += 1
                                    情绪B = 0
                                    printx(敌人AI信息B[1], 0.1)
                                    if ('饶恕' in 状态B):
                                        del 状态B[状态B.index("饶恕")]

                        if (攻击对象 == '4'):
                            printx(f'[{名字}]对[{敌人信息C[0]}]使用了[{技能名称储存[回答-1]}]', 0.1)
                            if('饶恕' in 状态C or 情绪C > 0):
                                if (not 折磨次数C>= int(敌人信息C[22])):
                                    防御C -= 5
                                    printx(敌人AI信息C[6], 0.1)
                                    printx(f'[{敌人信息C[0]}]的防御迅速减少!!',0.1)
                                    折磨次数C += 1
                                else:
                                    折磨次数C += 1
                                    情绪C = 2
                                    printx(敌人AI信息C[1], 0.1)
                                    if ('饶恕' in 状态C):
                                        del 状态C[状态C.index("饶恕")]

                        if (random.randint(1, int(攻击成功几率储存[回答-1])) == 1):
                            if (攻击对象 == '1'):
                                printx(f'[{名字}]没有成功对[{名字}]使用[{技能名称储存[回答-1]}]', 0.1)
                            if (攻击对象 == '2'):
                                printx(f'[{名字}]没有成功对[{敌人信息A[0]}]使用[{技能名称储存[回答-1]}]', 0.1)
                            if (攻击对象 == '3'):
                                printx(f'[{名字}]没有成功对[{敌人信息B[0]}]使用[{技能名称储存[回答-1]}]', 0.1)
                            if (攻击对象 == '4'):
                                printx(f'[{名字}]没有成功对[{敌人信息C[0]}]使用[{技能名称储存[回答-1]}]', 0.1)

                        elif (特殊说明储存[回答-1] == '攻击' or 特殊说明储存[回答-1] == '状态攻击'):
                            if (攻击对象 == '1'):
                                if (int(技能攻击储存[回答-1]) < 防御):
                                    printx(f'[{名字}]击中自己?? 但防御过大,免疫物理伤害', 0.1)
                                else:
                                    血量 -= (int(技能攻击储存[回答-1])+攻击)
                                    血量 += 防御
                                    printx(f'[{名字}]击中自己?? 血量减少{(int(技能攻击储存[回答-1])+攻击-防御)}', 0.1)
                                if (not int(破伤数据储存[回答-1]) == 0):
                                    血量 -= int(破伤数据储存[回答-1])
                                    printx(f'受到破伤攻击{(int(破伤数据储存[回答-1])+攻击)}血量', 0.1)

                                if (特殊说明储存[回答-1] == '状态攻击'):
                                    if ('一' in 特殊变量储存[回答-1]):
                                        状态等级 = 1
                                    if ('二' in 特殊变量储存[回答-1]):
                                        状态等级 = 2
                                    if ('三' in 特殊变量储存[回答-1]):
                                        状态等级 = 3

                                    if ('一' in 免疫状态):
                                        免疫等级 = 1
                                    if ('二' in 免疫状态):
                                        免疫等级 = 2
                                    if ('三' in 免疫状态):
                                        免疫等级 = 3
                                    if (not random.randint(1, round(int(攻击成功几率储存[回答-1])/2)) == 1):
                                        printx(
                                            f'[{名字}]受到{特殊变量储存[回答-1]}状态攻击!!', 0.1)
                                        if (免疫状态 == 特殊变量储存[回答-1]):
                                            if (免疫等级 >= 状态等级):
                                                printx(f'[{名字}]所携带的护符化解了所状态', 0.1)
                                        else:
                                            if (not 特殊变量储存[回答-1] in 状态):
                                                状态.append(特殊变量储存[回答-1])
                                                if ('良好' in 状态):
                                                    del 状态[状态.index('良好')]

                            if (攻击对象 == '2'):
                                if (int(技能攻击储存[回答-1])+攻击 < 防御A):
                                    printx(f'[{名字}]击中[{敌人信息A[0]}] 但防御过大,免疫物理伤害', 0.1)
                                else:
                                    血量A -= (int(技能攻击储存[回答-1])+攻击)                                
                                    血量A += 防御A
                                    printx(f'[{名字}]击中[{敌人信息A[0]}] 血量减少{(int(技能攻击储存[回答-1])+攻击-防御A)}', 0.1)
                                if (not int(破伤数据储存[回答-1]) == 0):
                                    血量A -= int(破伤数据储存[回答-1]) +攻击
                                    printx(f'受到破伤攻击{(int(破伤数据储存[回答-1])+攻击)}血量', 0.1)

                                if (特殊说明储存[回答-1] == '状态攻击'):
                                    if ('一' in 特殊变量储存[回答-1]):
                                        状态等级 = 1
                                    if ('二' in 特殊变量储存[回答-1]):
                                        状态等级 = 2
                                    if ('三' in 特殊变量储存[回答-1]):
                                        状态等级 = 3

                                    if ('一' in 免疫状态A):
                                        免疫等级 = 1
                                    if ('二' in 免疫状态A):
                                        免疫等级 = 2
                                    if ('三' in 免疫状态A):
                                        免疫等级 = 3
                                    
                                    if (not random.randint(1, round(int(攻击成功几率储存[回答-1])/2)) == 1):
                                        printx(f'[{敌人信息A[0]}]受到{特殊变量储存[回答-1]}状态攻击!!', 0.1)
                                        状态攻击属性 = 特殊变量储存[回答-1]
                                        状态攻击属性 = 状态攻击属性[0]
                                        if (免疫状态[0] == 状态攻击属性):
                                            if (免疫等级 >= 状态等级C):
                                                printx(f'[{敌人信息A[0]}]所携带的护符化解了所状态', 0.1)
                                        else:
                                            if (not 特殊变量储存[回答-1] in 状态A):
                                                状态A.append(特殊变量储存[回答-1])
                                                if ('良好' in 状态A):
                                                    del 状态A[状态A.index('良好')]

                            if (攻击对象 == '3'):
                                if (int(技能攻击储存[回答-1])+攻击 < 防御B):
                                    printx(f'[{名字}]击中[{敌人信息B[0]}] 但防御过大,免疫物理伤害', 0.1)
                                else:
                                    血量B -= (int(技能攻击储存[回答-1])+攻击)
                                    血量B += 防御B
                                    printx(f'[{名字}]击中[{敌人信息B[0]}] 血量减少{(int(技能攻击储存[回答-1])+攻击-防御B)}', 0.1)
                                if (not int(破伤数据储存[回答-1]) == 0):
                                    血量B -= int(破伤数据储存[回答-1])+攻击
                                    printx(f'受到破伤攻击{(int(破伤数据储存[回答-1])+攻击)}血量', 0.1)

                                if (特殊说明储存[回答-1] == '状态攻击'):
                                    if ('一' in 特殊变量储存[回答-1]):
                                        状态等级 = 1
                                    if ('二' in 特殊变量储存[回答-1]):
                                        状态等级 = 2
                                    if ('三' in 特殊变量储存[回答-1]):
                                        状态等级 = 3

                                    if ('一' in 免疫状态B):
                                        免疫等级 = 1
                                    if ('二' in 免疫状态B):
                                        免疫等级 = 2
                                    if ('三' in 免疫状态B):
                                        免疫等级 = 3

                                    if (not random.randint(1, round(int(攻击成功几率储存[回答-1])/2)) == 1):
                                        printx(f'[{敌人信息B[0]}]受到{特殊变量储存[回答-1]}状态攻击!!', 0.1)
                                        状态攻击属性 = 特殊变量储存[回答-1]
                                        状态攻击属性 = 状态攻击属性[0]
                                        if (免疫状态[0] == 状态攻击属性):
                                            if (免疫等级B >= 状态等级):
                                                printx(f'[{敌人信息B[0]}]所携带的护符化解了所状态', 0.1)
                                        else:
                                            if (not 特殊变量储存[回答-1] in 状态B):
                                                状态B.append(特殊变量储存[回答-1])
                                                if ('良好' in 状态B):
                                                    del 状态B[状态B.index('良好')]
                                            
                            if (攻击对象 == '4'):
                                if (int(技能攻击储存[回答-1])+攻击 < 防御C):
                                    printx(f'[{名字}]击中[{敌人信息C[0]}] 但防御过大,免疫物理伤害', 0.1)
                                else:
                                    血量C -= (int(技能攻击储存[回答-1])+攻击)
                                    血量C += 防御
                                    printx(f'[{名字}]击中[{敌人信息C[0]}] 血量减少{(int(技能攻击储存[回答-1])+攻击-防御C)}', 0.1)
                                if (not int(破伤数据储存[回答-1]) == 0):
                                    血量C -= int(破伤数据储存[回答-1])+攻击
                                    printx(f'受到破伤攻击{(int(破伤数据储存[回答-1])+攻击)}血量', 0.1)

                                if (特殊说明储存[回答-1] == '状态攻击'):
                                    if ('一' in 特殊变量储存[回答-1]):
                                        状态等级 = 1
                                    if ('二' in 特殊变量储存[回答-1]):
                                        状态等级 = 2
                                    if ('三' in 特殊变量储存[回答-1]):
                                        状态等级 = 3

                                    if ('一' in 免疫状态C):
                                        免疫等级 = 1
                                    if ('二' in 免疫状态C):
                                        免疫等级 = 2
                                    if ('三' in 免疫状态C):
                                        免疫等级 = 3

                                    if (not random.randint(1, round(int(攻击成功几率储存[回答-1])/2)) == 1):
                                        printx(f'[{敌人信息C[0]}]受到{特殊变量储存[回答-1]}状态攻击!!', 0.1)
                                        状态攻击属性 = 特殊变量储存[回答-1]
                                        状态攻击属性 = 状态攻击属性[0]
                                        if (免疫状态[0] == 状态攻击属性):
                                            if (免疫等级C >= 状态等级):
                                                printx(f'[{敌人信息C[0]}]所携带的护符化解了所状态', 0.1)
                                        else:
                                            if (not 特殊变量储存[回答-1] in 状态C):
                                                状态C.append(特殊变量储存[回答-1])
                                                if ('良好' in 状态C):
                                                    del 状态C[状态C.index('良好')]

                        elif (特殊说明储存[回答-1] == '攻击加强' or 特殊说明储存[回答-1] == '自以为是' or 特殊说明储存[回答-1] == '内力加强'  or 特殊说明储存[回答-1] == '防御加强'or 特殊说明储存[回答-1] == '血量增加'):
                            if (攻击对象 == '1'):
                                printx(f'[{名字}]成功使用[{技能名称储存[回答-1]}]', 0.1)
                                if (特殊说明储存[回答-1] == '攻击加强'):
                                    printx(f'[{名字}]攻击增加{特殊变量储存[回答-1]}', 0.1)
                                    攻击 += int(特殊变量储存[回答-1])

                                if (特殊说明储存[回答-1] == '自以为是'):
                                    printx(f'此技能似乎没啥子用???', 0.1)

                                if (特殊说明储存[回答-1] == '内力加强'):
                                    printx(f'[{名字}]内力增加{特殊变量储存[回答-1]}', 0.1)
                                    内力 += int(特殊变量储存[回答-1])
                                    if (内力 > 内力上限):
                                        内力 = 内力上限

                                if (特殊说明储存[回答-1] == '血量增加'):
                                    printx(f'[{名字}]血量增加{特殊变量储存[回答-1]}', 0.1)
                                    血量 += int(特殊变量储存[回答-1])
                                    if (血量 > 血量上限):
                                        血量 = 内血量上限

                                if (特殊说明储存[回答-1] == '防御加强'):
                                    printx(f'[{名字}]防御增加{特殊变量储存[回答-1]}', 0.1)
                                    防御 += int(特殊变量储存[回答-1])
                            else:
                                printx(f'你的敌人露出困惑的表情...技能无效!!', 0.1)

                        elif (特殊说明储存[回答-1] == '面子攻击' or 特殊说明储存[回答-1] == '情绪攻击'):
                            if (攻击对象 == '1'):
                                printx(f'你露出困惑的表情...‘你是不是知道了什么...’', 0.1)
                            else:
                                if (特殊说明储存[回答-1] == '面子攻击'):
                                    if (攻击对象 == '1'):
                                        printx('‘你是知道了什么嘛...’',0.1)
                                        面子A += int(特殊变量储存[回答-1])
                                    if (攻击对象 == '2'):
                                        printx(f'[{敌人信息A[0]}]的神情似乎变了...',0.1)
                                        面子A += int(特殊变量储存[回答-1])
                                    if (攻击对象 == '3'):
                                        printx(f'[{敌人信息B[0]}]的神情似乎变了...',0.1)
                                        面子B += int(特殊变量储存[回答-1])
                                    if (攻击对象 == '4'):
                                        printx(f'[{敌人信息B[0]}]的神情似乎变了...',0.1)
                                        面子C += int(特殊变量储存[回答-1])

                                if (特殊说明储存[回答-1] == '情绪攻击'):
                                    if (攻击对象 == '1'):
                                        printx(f'[{敌人信息A[0]}]的神情似乎变了...',0.1)
                                        情绪A += 特殊变量储存[回答-1]
                                    if (攻击对象 == '2'):
                                        printx(f'[{敌人信息B[0]}]的神情似乎变了...',0.1)
                                        情绪B += 特殊变量储存[回答-1]
                                    if (攻击对象 == '3'):
                                        printx(f'[{敌人信息B[0]}]的神情似乎变了...',0.1)
                                        情绪C += 特殊变量储存[回答-1]

                        elif (特殊说明储存[回答-1] == '敌方攻击减少' or 特殊说明储存[回答-1] == '敌方内力减少' or 特殊说明储存[回答-1] == '敌方防御减少'):
                            printx(f'[{名字}]成功使用[{技能名称储存[回答-1]}]', 0.1)
                            if (攻击对象 == '1'):
                                printx(f'‘停下你荒唐的选择!! 使用失效!!’',0.1)
                            if (攻击对象 == '2'):
                                if (特殊说明储存[回答-1] == '敌方攻击减少'):
                                    攻击A -= int(特殊变量储存[回答-1])
                                    printx(f'[{敌人信息A[0]}]的攻击减少{int(特殊变量储存[回答-1])}',0.1)
                                if (特殊说明储存[回答-1] == '敌方内力减少'):
                                    内力值A -= int(特殊变量储存[回答-1])
                                    printx(f'[{敌人信息A[0]}]的内力减少{int(特殊变量储存[回答-1])}',0.1)
                                if (特殊说明储存[回答-1] == '敌方防御减少'):
                                    防御A -= int(特殊变量储存[回答-1])
                                    printx(f'[{敌人信息A[0]}]的防御减少{int(特殊变量储存[回答-1])}',0.1)
                            if (攻击对象 == '3'):
                                if (特殊说明储存[回答-1] == '敌方攻击减少'):
                                    攻击B -= int(特殊变量储存[回答-1])
                                    printx(f'[{敌人信息B[0]}]的攻击减少{int(特殊变量储存[回答-1])}',0.1)
                                if (特殊说明储存[回答-1] == '敌方内力减少'):
                                    内力值B -= int(特殊变量储存[回答-1])
                                    printx(f'[{敌人信息B[0]}]的内力减少{int(特殊变量储存[回答-1])}',0.1)
                                if (特殊说明储存[回答-1] == '敌方防御减少'):
                                    防御B -= int(特殊变量储存[回答-1])
                                    printx(f'[{敌人信息B[0]}]的防御减少{int(特殊变量储存[回答-1])}',0.1)

                            if (攻击对象 == '4'):
                                if (特殊说明储存[回答-1] == '敌方攻击减少'):
                                    攻击C -= int(特殊变量储存[回答-1])
                                    printx(f'[{敌人信息C[0]}]的攻击减少{int(特殊变量储存[回答-1])}',0.1)
                                if (特殊说明储存[回答-1] == '敌方内力减少'):
                                    内力值C -= int(特殊变量储存[回答-1])
                                    printx(f'[{敌人信息C[0]}]的内力减少{int(特殊变量储存[回答-1])}',0.1)
                                if (特殊说明储存[回答-1] == '敌方防御减少'):
                                    防御C -= int(特殊变量储存[回答-1])
                                    printx(f'[{敌人信息C[0]}]的防御减少{int(特殊变量储存[回答-1])}',0.1)
                                    
                    if (回答 == '2'):
                        print('@-------------行动------------@')
                        print('1.交谈 2.查看')
                        回答B = ''
                        while True:
                            if (回答B == '1'):
                                break
                            if (回答B == '2'):
                                break
                            else:
                                回答B = input("输入操作 >>> ")

                        if (回答B == '1'):
                            print('@-------------交谈------------@')
                            攻击对象 = ''
                            printx('与谁对话?',0.1)
                            sleep(0.05)
                            if (敌人编号[1] == 'Nome'):
                                print(f'1.{敌人信息A[0]}')
                            elif (敌人编号[2] == 'Nome'):
                                print(f'1.{敌人信息A[0]} 2.{敌人信息B[0]}')
                            else:
                                print(f'1.{敌人信息A[0]} 2.{敌人信息B[0]} 3.{敌人信息C[0]}')
                            while True:
                                if (攻击对象 == '1' and not 敌人编号[0] == 'Nome'):
                                    break
                                if (攻击对象 == '2' and not 敌人编号[1] == 'Nome'):
                                    break
                                if (攻击对象 == '3' and not 敌人编号[2] == 'Nome'):
                                    break
                                else:
                                    攻击对象 = input("输入操作 >>> ")
                            print('O-----------------------------O')
                            printx('要与它讲述什么话题?', 0.1)
                            sleep(0.05)
                            print('1.我们不要再打了')
                            sleep(0.05)
                            print('2.我们可以当朋友')
                            sleep(0.05)
                            print('3.我可以亲手毁掉你')
                            sleep(0.05)
                            回答 = ''
                            while True:
                                if (回答 == '1' or 回答 == '2' or 回答 == '3' or 回答 == '4'):
                                    break
                                else:
                                    回答 = input("输入操作 >>> ")
                            print('O-----------------------------O')
                            if (回答 == '1' and 攻击对象 == '1'):
                                printx(f'你劝说着[{敌人信息A[0]}]不要再打下去了,那样没意义',0.1)
                                if (not 折磨次数A >= int(敌人信息A[22])):
                                    if (敌人信息A[12] == '被攻击'):
                                        printx('这时你的敌人看你的眼神像看一个傻子似的...',0.1)
                                        printx('不过它还是决定原谅你之前奇特的举动',0.1)
                                        if (not '饶恕' in 状态A):
                                            状态A.append('饶恕')
                                    else:
                                        面子A += 1
                                        if (面子A > int(敌人信息A[9])):
                                            printx(f'[{敌人信息A[0]}]停下了攻击...', 0.1)
                                            if (not '饶恕' in 状态A):
                                                状态A.append('饶恕')
                                else:
                                    printx('它已经不想再听你的话了!!!',0.1)

                            if (回答 == '1' and 攻击对象 == '2'):
                                printx(f'你劝说着[{敌人信息B[0]}]不要再打下去了,那样没意义', 0.1)
                                if (not 折磨次数B >= int(敌人信息B[22])):
                                    if (敌人信息B[12] == '被攻击'):
                                        printx('这时你的敌人看你的眼神像看一个傻子似的...', 0.1)
                                        printx('不过它还是决定原谅你之前奇特的举动', 0.1)
                                        if (not '饶恕' in 状态B):
                                            状态B.append('饶恕')
                                    else:
                                        面子B += 1
                                        if (面子B > int(敌人信息B[9])):
                                            printx(f'[{敌人信息B[0]}]停下了攻击...', 0.1)
                                            if (not '饶恕' in 状态B):
                                                状态B.append('饶恕')
                                else:
                                    printx('它已经不想再听你的话了!!!',0.1)

                            if (回答 == '1' and 攻击对象 == '3'):
                                printx(f'你劝说着[{敌人信息C[0]}]不要再打下去了,那样没意义', 0.1)
                                if (not 折磨次数C >= int(敌人信息C[22])):
                                    if (敌人信息C[12] == '被攻击'):
                                        printx('这时你的敌人看你的眼神像看一个傻子似的...', 0.1)
                                        printx('不过它还是决定原谅你之前奇特的举动', 0.1)
                                        if (not '饶恕' in 状态C):
                                            状态C.append('饶恕')
                                    else:
                                        面子C += 1
                                        if (情绪C > int(敌人信息C[9])):
                                            printx(f'[{敌人信息C[0]}]停下了攻击...', 0.1)
                                            if (not '饶恕' in 状态C):
                                                状态C.append('饶恕')
                                else:
                                    printx('它已经不想再听你的话了!!!',0.1)

                            if (回答 == '2' and 攻击对象 == '1'):
                                if (not 折磨次数A >= int(敌人信息A[22])):
                                    printx(f'你向[{敌人信息A[0]}]说着我们可以当朋友的', 0.1)
                                    if (敌人信息A[12] == '被攻击'):
                                        printx('你的敌人目前的智商憨逼爱因斯坦...?', 0.1)
                                        printx('不过它还是决定原谅你之前奇特的举动啦~', 0.1)
                                        if (not '饶恕' in 状态A):
                                            状态A.append('饶恕')
                                    else:
                                        if (情绪A == 0):
                                            printx(敌人AI信息A[2], 0.1)
                                        情绪A += 1
                                        if (情绪A > int(敌人信息A[11])):
                                            printx(f'[{敌人信息A[0]}]停下了攻击,微微的点了点头', 0.1)
                                            if (not '饶恕' in 状态A):
                                                状态A.append('饶恕')
                                else:
                                    printx('它已经不想再听你的话了!!!',0.1)

                            if (回答 == '2' and 攻击对象 == '2'):
                                if (not 折磨次数B >= int(敌人信息B[22])):
                                    printx(f'你向[{敌人信息B[0]}]说着我们可以当朋友的', 0.1)
                                    if (敌人信息B[12] == '被攻击'):
                                        printx('你的敌人目前的智商憨逼爱因斯坦...?', 0.1)
                                        printx('不过它还是决定原谅你之前奇特的举动啦~', 0.1)
                                        if (not '饶恕' in 状态B):
                                            状态B.append('饶恕')
                                    else:
                                        if (情绪B == 0):
                                            printx(敌人AI信息B[2], 0.1)
                                        情绪B += 1
                                        if (情绪B > int(敌人信息B[11])):
                                            printx(f'[{敌人信息B[0]}]停下了攻击,微微的点了点头', 0.1)
                                            if (not '饶恕' in 状态B):
                                                状态B.append('饶恕')
                                else:
                                    printx('它已经不想再听你的话了!!!',0.1)

                            if (回答 == '2' and 攻击对象 == '3'):
                                printx(f'你向[{敌人信息C[0]}]说着我们可以当朋友的', 0.1)
                                if (not 折磨次数C >= int(敌人信息C[22])):
                                    if (敌人信息C[12] == '被攻击'):
                                        printx('你的敌人目前的智商憨逼爱因斯坦...?', 0.1)
                                        printx('不过它还是决定原谅你之前奇特的举动啦~', 0.1)
                                        if (not '饶恕' in 状态C):
                                            状态C.append('饶恕')
                                    else:
                                        if (情绪C == 0):
                                            printx(敌人AI信息C[2], 0.1)
                                        情绪C += 1
                                        if (面子C > int(敌人信息C[11])):
                                            printx(f'[{敌人信息C[0]}]停下了攻击,微微的点了点头', 0.1)
                                            if (not '饶恕' in 状态C):
                                                状态C.append('饶恕')
                                else:
                                    printx('它已经不想再听你的话了!!!',0.1)

                            if (回答 == '3' and 攻击对象 == '3'):
                                printx(f'你讲述着[{敌人信息C[0]}]很快会失去意识了', 0.1)
                                if (敌人信息C[12] == '攻击'):
                                    printx('但你的敌人似乎不放在心上', 0.1)
                                    printx('因为它也想那么做...', 0.1)
                                if (not 敌人信息C[12] == '攻击'):
                                    情绪C -= 1
                                    if (情绪C < int(敌人信息A[10])):
                                        printx(f'它在害怕!!!', 0.1)
                                        if (not '饶恕' in 状态C):
                                            状态C.append('饶恕')

                            if (回答 == '3' and 攻击对象 == '1'):
                                printx(f'你讲述着[{敌人信息A[0]}]很快会失去意识了', 0.1)
                                if (敌人信息A[12] == '攻击'):
                                    printx('但你的敌人似乎不放在心上', 0.1)
                                    printx('因为它也想那么做...', 0.1)
                                if (not 敌人信息A[12] == '攻击'):
                                    情绪A -= 1
                                    if (情绪A < int(敌人信息A[10])):
                                        printx(f'它在害怕!!!', 0.1)
                                        if (not '饶恕' in 状态A):
                                            状态A.append('饶恕')

                            if (回答 == '3' and 攻击对象 == '2'):
                                printx(f'你讲述着[{敌人信息B[0]}]很快会失去意识了', 0.1)
                                if (敌人信息B[12] == '攻击'):
                                    printx('但你的敌人似乎不放在心上', 0.1)
                                    printx('因为它也想那么做...', 0.1)
                                if (not 敌人信息B[12] == '攻击'):
                                    情绪B -= 1
                                    if (情绪B < int(敌人信息B[10])):
                                        printx(f'它在害怕!!!', 0.1)
                                        if (not '饶恕' in 状态B):
                                            状态B.append('饶恕')

                        if (回答B == '2'):
                            print('@-------------查看------------@')
                            printx('选择查看对象?',0.1)
                            sleep(0.05)
                            if (敌人编号[1] == 'Nome'):
                                print(f'1.{名字} 2.{敌人信息A[0]}')
                            elif (敌人编号[2] == 'Nome'):
                                print(f'1.{名字} 2.{敌人信息A[0]} 3.{敌人信息B[0]}')
                            else:
                                print(f'1.{名字} 2.{敌人信息A[0]} 3.{敌人信息B[0]} 4.{敌人信息C[0]}')
                            回答B = ''
                            while True:
                                if (回答B == '1'):
                                    break
                                if (回答B == '2' and not 敌人编号[0] == 'Nome'):
                                    break
                                if (回答B == '3' and not 敌人编号[1] == 'Nome'):
                                    break
                                if (回答B == '4' and not 敌人编号[2] == 'Nome'):
                                    break
                                else:
                                    回答B = input("输入操作 >>> ")
                            if (回答B == '1'):
                                查看的武器 = 物品信息列表[武器]
                                查看的武器 = 查看的武器.split(',')
                                查看的武器 = 查看的武器[0]
                                查看的防具 = 物品信息列表[防具]
                                查看的防具 = 查看的武器.split(',')
                                查看的防具 = 查看的防具[0]
                                查看的护符 = 物品信息列表[护符]
                                查看的护符 = 查看的护符.split(',')
                                查看的护符 = 查看的护符[0]
                                printx(f'[{名字}]  攻击:{攻击} 防御:{防御} 内力上限:{内力值}', 0.1)
                                printx(f'[{名字}]  武器:{查看的武器} 防具:{查看的防具} 护符:{查看的护符}', 0.1)

                            if (回答B == '2'):
                                查看的武器 = 物品信息列表[武器A]
                                查看的武器 = 查看的武器.split(',')
                                查看的武器 = 查看的武器[0]
                                查看的防具 = 物品信息列表[防具A]
                                查看的防具 = 查看的武器.split(',')
                                查看的防具 = 查看的防具[0]
                                查看的护符 = 物品信息列表[护符A]
                                查看的护符 = 查看的护符.split(',')
                                查看的护符 = 查看的护符[0]
                                printx(f'{敌人信息A[0]}  攻击:{攻击A} 防御:{防御A} 内力上限:{内力值A}', 0.1)
                                printx(f'{敌人信息A[0]}  武器:{查看的武器} 防具:{查看的防具} 护符:{查看的护符}', 0.1)

                            if (回答B == '3'):
                                查看的武器 = 物品信息列表[武器B]
                                查看的武器 = 查看的武器.split(',')
                                查看的武器 = 查看的武器[0]
                                查看的防具 = 物品信息列表[防具B]
                                查看的防具 = 查看的武器.split(',')
                                查看的防具 = 查看的防具[0]
                                查看的护符 = 物品信息列表[护符B]
                                查看的护符 = 查看的护符.split(',')
                                查看的护符 = 查看的护符[0]
                                printx(f'{敌人信息B[0]}  攻击:{攻击B} 防御:{防御B} 内力上限:{内力值B}', 0.1)
                                printx(f'{敌人信息B[0]}  武器:{查看的武器} 防具:{查看的防具} 护符:{查看的护符}', 0.1)

                            if (回答B == '4'):
                                查看的武器 = 物品信息列表[武器C]
                                查看的武器 = 查看的武器.split(',')
                                查看的武器 = 查看的武器[0]
                                查看的防具 = 物品信息列表[防具C]
                                查看的防具 = 查看的武器.split(',')
                                查看的防具 = 查看的防具[0]
                                查看的护符 = 物品信息列表[护符C]
                                查看的护符 = 查看的护符.split(',')
                                查看的护符 = 查看的护符[0]
                                printx(f'{敌人信息C[0]}  攻击:{攻击C} 防御:{防御C} 内力上限:{内力值C}', 0.1)
                                printx(f'{敌人信息C[0]}  武器:{查看的武器} 防具:{查看的防具} 护符:{查看的护符}', 0.1)

                        回答 = ''

                    if (回答 == '3'):
                        背包系统整理()
                        回答 = ''

                    if (回答 == '4'):
                        print('@-------------原谅------------@')
                        if (敌人编号[1] == 'Nome'):
                            if('饶恕' in 状态A):
                                printx('你原谅了你的敌人对你的伤害',0.1)
                                胜利条件 = '饶恕'
                                break
                        elif (敌人编号[2] == 'Nome'):
                            if('饶恕' in 状态A and '饶恕' in 状态B):
                                printx('你原谅了你的敌人对你的伤害',0.1)
                                胜利条件 = '饶恕'
                                break
                            if('濒死' in 状态A and '饶恕' in 状态B):
                                printx('你原谅了你的敌人对你的伤害',0.1)
                                胜利条件 = '半饶恕'
                                break
                            if('饶恕' in 状态A and '濒死' in 状态B):
                                printx('你原谅了你的敌人对你的伤害',0.1)
                                胜利条件 = '半饶恕'
                                break
                        else:
                            if('饶恕' in 状态A and '饶恕' in 状态B and '饶恕' in 状态C):
                                printx('你原谅了你的敌人对你的伤害',0.1)
                                胜利条件 = '饶恕'
                                break
                            if('濒死' in 状态A and '饶恕' in 状态B and '饶恕' in 状态C):
                                printx('你原谅了你的敌人对你的伤害',0.1)
                                胜利条件 = '半饶恕'
                                break
                            if('饶恕' in 状态A and '濒死' in 状态B and '饶恕' in 状态C):
                                printx('你原谅了你的敌人对你的伤害',0.1)
                                胜利条件 = '半饶恕'
                                break
                            if('饶恕' in 状态A and '饶恕' in 状态B and '濒死' in 状态C):
                                printx('你原谅了你的敌人对你的伤害',0.1)
                                胜利条件 = '半饶恕'
                                break
                            if('濒死' in 状态A and '濒死' in 状态B and '饶恕' in 状态C):
                                printx('你原谅了你的敌人对你的伤害',0.1)
                                胜利条件 = '半饶恕'
                                break
                            if('饶恕' in 状态A and '濒死' in 状态B and '濒死' in 状态C):
                                printx('你原谅了你的敌人对你的伤害',0.1)
                                胜利条件 = '半饶恕'
                                break

                        if (敌人信息A[12] == '被攻击'):
                            printx('你的敌人表示很疑惑??',0.1)
                            printx('他们要你给个说法才让你走',0.1)
                        else:
                            printx('有敌人没有想放过你',0.1)
                            printx('你得让它也得放过你,你才能走',0.1)
                    
                print(f'O-----------敌方回合----------O')
                # 屑列表集合
                免疫等级 = 0
                状态等级 = 0
                if (敌人编号[1] == 'Nome'):
                    敌人名称编号 = [敌人信息A[0]]
                    血量储存 = [血量A]
                elif (敌人编号[2] == 'Nome'):
                    敌人名称编号 = [敌人信息A[0],敌人信息B[0]]
                    血量储存 = [血量A,血量B]
                else:
                    敌人名称编号 = [敌人信息A[0],敌人信息B[0],敌人信息C[0]]
                    血量储存 = [血量A, 血量B, 血量C]
                敌人执行编号 = -1
                for __count in range(len(敌人名称编号)):
                    敌人执行编号 += 1
                    if (敌人执行编号 == 0):
                        敌方攻击 = 攻击A
                        敌方特殊说明储存 = 特殊说明储存A
                        敌方状态 = 状态A
                        技能名称储存储存 = [技能名称储存A[0],技能名称储存A[1],技能名称储存A[2],技能名称储存A[3]]
                        敌人攻击成功几率储存 = [攻击成功几率储存A[0],攻击成功几率储存A[1],攻击成功几率储存A[2],攻击成功几率储存A[3]]
                        
                    if (敌人执行编号 == 1):
                        敌方攻击 = 攻击B
                        敌方特殊说明储存 = 特殊说明储存B
                        敌方状态 = 状态B
                        技能名称储存储存 = [技能名称储存B[0],技能名称储存B[1],技能名称储存B[2],技能名称储存B[3]]
                        敌人攻击成功几率储存 = [攻击成功几率储存B[0],攻击成功几率储存B[1],攻击成功几率储存B[2],攻击成功几率储存B[3]]
                        
                    if (敌人执行编号 == 2):
                        敌方攻击 = 攻击C
                        敌方特殊说明储存 = 特殊说明储存C
                        敌方状态 = 状态C
                        技能名称储存储存 = [技能名称储存C[0],技能名称储存C[1],技能名称储存C[2],技能名称储存C[3]]
                        敌人攻击成功几率储存 = [攻击成功几率储存C[0],攻击成功几率储存C[1],攻击成功几率储存C[2],攻击成功几率储存C[3]]

                    if (血量储存[敌人执行编号] > 0 and not '饶恕' in 敌方状态):
                        if ('濒死' in 状态A):
                            del 状态A[状态A.index('濒死')]
                        if ('濒死' in 状态B):
                            del 状态B[状态B.index('濒死')]
                        if ('濒死' in 状态C):
                            del 状态C[状态C.index('濒死')]
                        printx(f'[{敌人名称编号[敌人执行编号]}]的回合:', 0.1)
                        if (not 技能名称储存储存[0] == '----'):
                            随机技能选择范围 = 0
                        if (not 技能名称储存储存[1] == '----'):
                            随机技能选择范围 = 1
                        if (not 技能名称储存储存[2] == '----'):
                            随机技能选择范围 = 2
                        if (not 技能名称储存储存[3] == '----'):
                            随机技能选择范围 = 3
                        技能选取 = random.randint(0,随机技能选择范围)
                        while True:
                            if (int(内力消耗储存A[(技能选取)]) < 内力值A):
                                break
                            else:
                                技能选取 = random.randint(1,随机技能选择范围)
                        printx(f'[{敌人名称编号[敌人执行编号]}]对[{名字}]使用[{技能名称储存储存[技能选取]}]',0.1)
                        if (敌人执行编号 == 0):
                            if ('一' in 特殊变量储存A[技能选取]):
                                状态等级 = 1
                            if ('二' in 特殊变量储存A[技能选取]):
                                状态等级 = 2
                            if ('三' in 特殊变量储存A[技能选取]):
                                状态等级 = 3
                            内力值A -= int(内力消耗储存A[技能选取])
                        if (敌人执行编号 == 1):
                            if ('一' in 特殊变量储存B[技能选取]):
                                状态等级 = 1
                            if ('二' in 特殊变量储存B[技能选取]):
                                状态等级 = 2
                            if ('三' in 特殊变量储存B[技能选取]):
                                状态等级 = 3
                            内力值B -= int(内力消耗储存B[技能选取])
                        if (敌人执行编号 == 2):
                            if ('一' in 特殊变量储存C[技能选取]):
                                状态等级 = 1
                            if ('二' in 特殊变量储存C[技能选取]):
                                状态等级 = 2
                            if ('三' in 特殊变量储存C[技能选取]):
                                状态等级 = 3
                            内力值C -= int(内力消耗储存C[技能选取])

                        if (random.randint(1, int(敌人攻击成功几率储存[技能选取])) == 1):
                            printx(f'[{敌人名称编号[敌人执行编号]}]没有成功对[{名字}]使用[{技能名称储存储存[技能选取]}]', 0.1)
                        else:
                            if ('一' in 免疫状态):
                                免疫等级 = 1
                            if ('二' in 免疫状态):
                                免疫等级 = 2
                            if ('三' in 免疫状态):
                                免疫等级 = 3
                            
                            if (敌方特殊说明储存[技能选取] == '攻击' or 敌方特殊说明储存[技能选取] == '状态攻击'):
                                攻击伤害 = (int(技能攻击储存A[技能选取]) + 敌方攻击) - 防御
                                if (攻击伤害 < 防御):
                                    printx(f'[{名字}]因防御过大,免疫伤害', 0.1)
                                else:
                                    血量 -= (int(技能攻击储存A[技能选取]) + 敌方攻击)
                                    血量 += 防御
                                    printx(f'[{敌人名称编号[敌人执行编号]}]击中[{名字}] 血量减少{(攻击伤害)}', 0.1)
                                
                                if (not int(破伤数据储存A[技能选取]) == 0):
                                    血量 -= int(破伤数据储存A[技能选取])
                                    printx(f'受到破伤攻击{(int(破伤数据储存A[技能选取])+攻击)}血量', 0.1)

                                if (敌方特殊说明储存[技能选取] == '状态攻击'):
                                    if (敌人执行编号 == 0):
                                        if (not random.randint(1, round(int(敌人攻击成功几率储存[技能选取])/2)) == 1):
                                            printx(f'[{名字}]受到{特殊变量储存A[技能选取]}状态攻击!!', 0.1)
                                            状态攻击属性 = 特殊变量储存A[技能选取]
                                            状态攻击属性 = 状态攻击属性[0]
                                            if (免疫状态[0] == 状态攻击属性):
                                                if (免疫等级 >= 状态等级):
                                                    printx(f'[{名字}]所携带的护符化解了所状态', 0.1)
                                            else:
                                                if (not 特殊变量储存A[技能选取] in 状态):
                                                    状态.append(特殊变量储存A[技能选取])
                                                    if ('良好' in 状态):
                                                        del 状态[状态.index('良好')]

                                    if (敌人执行编号 == 1):
                                        if (not random.randint(1, round(int(敌人攻击成功几率储存[技能选取])/2)) == 1):
                                            printx(f'[{名字}]受到{特殊变量储存B[技能选取]}状态攻击!!', 0.1)
                                            状态攻击属性 = 特殊变量储存B[技能选取]
                                            状态攻击属性 = 状态攻击属性[0]
                                            
                                            if (免疫状态[0] == 状态攻击属性):
                                                if (免疫等级 >= 状态等级):
                                                    printx(f'[{名字}]所携带的护符化解了所状态', 0.1)
                                            else:
                                                if (not 特殊变量储存B[技能选取] in 状态):
                                                    状态.append(特殊变量储存B[技能选取])
                                                    if ('良好' in 状态):
                                                        del 状态[状态.index('良好')]

                                    if (敌人执行编号 == 2):
                                        if (not random.randint(1, round(int(敌人攻击成功几率储存[技能选取])/2)) == 1):
                                            printx(f'[{名字}]受到{特殊变量储存C[技能选取]}状态攻击!!', 0.1)
                                            状态攻击属性 = 特殊变量储存C[技能选取]
                                            状态攻击属性 = 状态攻击属性[0]
                                            if (免疫状态 == 特殊变量储存C[技能选取]):
                                                if (免疫等级[0] >= 状态攻击属性):
                                                    printx(f'[{名字}]所携带的护符化解了所状态', 0.1)
                                            else:
                                                if (not 特殊变量储存C[技能选取] in 状态):
                                                    状态.append(特殊变量储存C[技能选取])
                                                    if ('良好' in 状态):
                                                        del 状态[状态.index('良好')]
                                            
                            if (敌方特殊说明储存[技能选取] == '攻击加强' or 敌方特殊说明储存[技能选取] == '自以为是' or 敌方特殊说明储存[技能选取] == '内力加强' or 敌方特殊说明储存[技能选取] == '防御加强' or 敌方特殊说明储存[技能选取] == '血量增加'):
                                if (敌方特殊说明储存[技能选取] == '攻击加强'):
                                    if (敌人执行编号 == 0):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]攻击增加{特殊变量储存A[技能选取]}', 0.1)
                                        攻击A += int(特殊变量储存A[技能选取])
                                    if (敌人执行编号 == 1):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]攻击增加{特殊变量储存B[技能选取]}', 0.1)
                                        攻击B += int(特殊变量储存B[技能选取])
                                    if (敌人执行编号 == 2):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]攻击增加{特殊变量储存C[技能选取]}', 0.1)
                                        攻击C += int(特殊变量储存C[技能选取])

                                if (敌方特殊说明储存[技能选取] == '自以为是'):
                                    printx(f'此技能似乎没啥子用???', 0.1)

                                if (敌方特殊说明储存[技能选取] == '内力加强'):
                                    if (敌人执行编号 == 0):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]内力增加{特殊变量储存A[技能选取]}', 0.1)
                                        内力值A += int(特殊变量储存A[技能选取])
                                        if (内力值A > 内力值A上限):
                                            内力值A = 内力值A上限
                                    if (敌人执行编号 == 1):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]内力增加{特殊变量储存B[技能选取]}', 0.1)
                                        内力值B += int(特殊变量储存B[技能选取])
                                        if (内力值B > 内力值B上限):
                                            内力值B = 内力值B上限
                                    if (敌人执行编号 == 2):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]内力增加{特殊变量储存C[技能选取]}', 0.1)
                                        内力值C += int(特殊变量储存C[技能选取])
                                        if (内力值C > 内力值C上限):
                                            内力值C = 内力值C上限

                                if (敌方特殊说明储存[技能选取] == '血量增加'):
                                    if (敌人执行编号 == 0):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]血量增加{特殊变量储存A[技能选取]}', 0.1)
                                        血量A += int(特殊变量储存A[技能选取])
                                        if (血量A > 血量A上限):
                                            血量A = 血量A上限

                                    if (敌人执行编号 == 1):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]血量增加{特殊变量储存B[技能选取]}', 0.1)
                                        血量B += int(特殊变量储存B[技能选取])
                                        if (血量B > 血量B上限):
                                            血量B = 血量B上限

                                    if (敌人执行编号 == 2):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]血量增加{特殊变量储存C[技能选取]}', 0.1)
                                        血量C += int(特殊变量储存C[技能选取])
                                        if (血量C > 血量C上限):
                                            血量C = 血量C上限

                                if (敌方特殊说明储存[技能选取] == '防御加强'):
                                    if (敌人执行编号 == 0):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]防御增加{特殊变量储存A[技能选取]}', 0.1)
                                        防御A += int(特殊变量储存A[技能选取])
                                    if (敌人执行编号 == 1):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]防御增加{特殊变量储存B[技能选取]}', 0.1)
                                        防御B += int(特殊变量储存B[技能选取])
                                    if (敌人执行编号 == 2):
                                        printx(f'[{敌人名称编号[敌人执行编号]}]防御增加{特殊变量储存C[技能选取]}', 0.1)
                                        防御C += int(特殊变量储存C[技能选取])

                        if (敌方特殊说明储存[技能选取] == '面子攻击' or 敌方特殊说明储存[技能选取] == '情绪攻击'):
                            printx(f'当然...你是不会被这些记事本所打动的', 0.1)
                            
                    else:
                        if ('饶恕' in 敌方状态):
                            printx(f'[{敌人名称编号[敌人执行编号]}]不想再和你打了...', 0.1)
                        else:
                            printx(f'[{敌人名称编号[敌人执行编号]}]重伤倒地 昏迷不醒中...', 0.1)
                            if (敌人执行编号 == 0):
                                if (not '濒死' in 状态A):
                                    状态A.append('濒死')

                            if (敌人执行编号 == 1):
                                if (not '濒死' in 状态B):
                                    状态B.append('濒死')

                            if (敌人执行编号 == 2):
                                if (not '濒死' in 状态C):
                                    状态C.append('濒死')

                    print('O-----------------------------O')

                if (血量 <= 0):
                    printx(f'[{名字}]倒下了,你无法得知外界的信息,你晕了过去...',0.1)
                    if (not '饶恕' in 状态):
                        状态.append('濒死')

                print('')
                回合数 += 1

            if (敌人编号[1] == 'Nome'):
                printx(f'战斗胜利!! 获得{敌人信息A[13]}金币 {敌人信息A[14]}经验', 0.1)
                金币 += int(敌人信息A[13])
                经验 += int(敌人信息A[14])
                if (not random.randint(1, int(敌人信息A[16])) == 1 and not int(敌人信息A[15]) == 0):
                    printx(f'获得[{敌人信息A[17]}]并放入[背包]中', 0.1)
                    获得物品(int(敌人信息A[15]))

            elif (敌人编号[2] == 'Nome'):
                printx(f'战斗胜利!! 获得{int(敌人信息A[13]) + int(敌人信息B[13])}金币 {int(敌人信息A[14]) + int(敌人信息B[14])}经验', 0.1)
                金币 += int(敌人信息A[13]) + int(敌人信息B[13])
                经验 += int(敌人信息A[14]) + int(敌人信息B[14])
                if (not random.randint(1, int(敌人信息A[16])) == 1 and not int(敌人信息A[15]) == 0):
                    printx(f'获得[{敌人信息A[17]}]并放入[背包]中', 0.1)
                    获得物品(int(敌人信息A[15]))
                if (not random.randint(1, int(敌人信息B[16])) == 1 and not int(敌人信息B[15]) == 0):
                    printx(f'获得[{敌人信息B[17]}]并放入[背包]中', 0.1)
                    获得物品(int(敌人信息B[15]))
            else:
                printx(f'战斗胜利!! 获得{int(敌人信息A[13]) + int(敌人信息B[13]) + int(敌人信息C[13])}金币 {int(敌人信息A[14]) + int(敌人信息B[14]) + int(敌人信息C[14])}经验', 0.1)
                金币 += int(敌人信息A[13]) + int(敌人信息B[13]) + int(敌人信息C[13])
                经验 += int(敌人信息A[14]) + int(敌人信息B[14]) + int(敌人信息C[14])
                if (not random.randint(1, int(敌人信息A[16])) == 1 and not int(敌人信息A[15]) == 0):
                    printx(f'获得[{敌人信息A[17]}]并放入[背包]中', 0.1)
                    获得物品(int(敌人信息A[15]))
                if (not random.randint(1, int(敌人信息B[16])) == 1 and not int(敌人信息B[15]) == 0):
                    printx(f'获得[{敌人信息B[17]}]并放入[背包]中', 0.1)
                    获得物品(int(敌人信息B[15]))
                if (not random.randint(1, int(敌人信息C[16])) == 1 and not int(敌人信息C[15]) == 0):
                    printx(f'获得[{敌人信息C[17]}]并放入[背包]中', 0.1)
                    获得物品(int(敌人信息C[15]))
            战斗是 = 'NO'

        elif (说话系统_语言列表[说话内容] == "[剧情选择观看]"):
            printx("是否观看下面剧情?",0.1)
            回答 = input("1.是 2.否>>> ")
            if (回答 == '2'):
                break
                
        elif (说话系统_语言列表[说话内容] == "[打印]"):
            printx(说话系统_语言列表[说话内容+1],0.1)
        说话内容 += 1

def 读取章节():
    global 章节列表
    global 名字
    global 章节
    global 写入的信息
    global 说话文件编号
    global 回答
    with open("数据储存/存档/名字") as f:
        名字 = f.read()
    章节内容 = 0
    # 储存章节编号内所指示的数据
    章节系统_语言列表 = 章节列表[章节]
    章节系统_语言列表 = 章节系统_语言列表.split(',')
    重复章节可执行数 = len(章节系统_语言列表)
    # 也等同于起始章节内容的开始话句
    for __count in range(重复章节可执行数):
        if (章节系统_语言列表[章节内容] == "说话编号"):
            说话文件编号 = int(章节系统_语言列表[章节内容+1])
            说话系统()

        if (章节系统_语言列表[章节内容] == "特殊指令"):
            if (章节系统_语言列表[章节内容+1] == '1'):
                名字 = 回答
                if (len(名字) > 7):
                    名字 = '感觉名字起长就很了不起的屑'
                if (名字 == '暗'):
                    名字 = '[IP:]'
                if (名字 == ''):
                    名字 = '霆'

        if (章节系统_语言列表[章节内容] == '分支线路-方案1'):
            if(胜利条件 == '饶恕'):
                说话文件编号 = int(章节系统_语言列表[章节内容+1])
                说话系统()
            if(胜利条件 == '半饶恕'):
                说话文件编号 = int(章节系统_语言列表[章节内容+2])
                说话系统()
            if(胜利条件 == '杀死'):
                说话文件编号 = int(章节系统_语言列表[章节内容+3])
                说话系统()

        if (章节系统_语言列表[章节内容] == "发送邮件"):
            写入的信息 = 章节系统_语言列表[章节内容+1]
            写信息()

        if (章节系统_语言列表[章节内容] == "保存"):
            保存()

        if (章节系统_语言列表[章节内容] == "读档"):
            读档()
        
        if (章节系统_语言列表[章节内容] == '变量设置'):
            if (章节系统_语言列表[章节内容+1] == '人物死亡名称列表'):
                人物死亡名称列表.append(章节系统_语言列表[章节内容+2])
                
        章节内容 += 1

读档()
读取章节()
# 说话编号,0,特殊指令,说话编号,1,分支线路-方案1,2,2,3,说话编号,4,发送邮件,我...成功了吗?如果成功了，请在开始的时候输入0吧...,保存/第一章